/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 3.0.7
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */

#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif


#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
# undef _DEBUG
# include <Python.h>
# define _DEBUG
#else
# include <Python.h>
#endif

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows to return the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
#define SWIG_ERROR                 (-1)
#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = ((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = ((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13



/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

#ifndef Py_TYPE
#  define Py_TYPE(op) ((op)->ob_type)
#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif


/* Warning: This function will allocate a new string in Python 3,
 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 */
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03000000
  char *cstr;
  char *newstr;
  Py_ssize_t len;
  str = PyUnicode_AsUTF8String(str);
  PyBytes_AsStringAndSize(str, &cstr, &len);
  newstr = (char *) malloc(len+1);
  memcpy(newstr, cstr, len+1);
  Py_XDECREF(str);
  return newstr;
#else
  return PyString_AsString(str);
#endif
}

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#else
#  define SWIG_Python_str_DelForPy3(x) 
#endif


SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
#  define PyOS_snprintf _snprintf
# else
#  define PyOS_snprintf snprintf
# endif
#endif

/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000

#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif

static PyObject *
PyString_FromFormat(const char *fmt, ...) {
  va_list ap;
  char buf[SWIG_PYBUFFER_SIZE * 2];
  int res;
  va_start(ap, fmt);
  res = vsnprintf(buf, sizeof(buf), fmt, ap);
  va_end(ap);
  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
}
#endif

/* Add PyObject_Del for old Pythons */
#if PY_VERSION_HEX < 0x01060000
# define PyObject_Del(op) PyMem_DEL((op))
#endif
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

/* A crude PyExc_StopIteration exception for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# ifndef PyExc_StopIteration
#  define PyExc_StopIteration PyExc_RuntimeError
# endif
# ifndef PyObject_GenericGetAttr
#  define PyObject_GenericGetAttr 0
# endif
#endif

/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
#  define Py_NotImplemented PyExc_RuntimeError
# endif
#endif

/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
# endif
#endif

/* PySequence_Size for old Pythons */
#if PY_VERSION_HEX < 0x02000000
# ifndef PySequence_Size
#  define PySequence_Size PySequence_Length
# endif
#endif

/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
PyObject *PyBool_FromLong(long ok)
{
  PyObject *result = ok ? Py_True : Py_False;
  Py_INCREF(result);
  return result;
}
#endif

/* Py_ssize_t for old Pythons */
/* This code is as recommended by: */
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intintargfunc ssizessizeargfunc;
typedef intobjargproc ssizeobjargproc;
typedef intintobjargproc ssizessizeobjargproc;
typedef getreadbufferproc readbufferproc;
typedef getwritebufferproc writebufferproc;
typedef getsegcountproc segcountproc;
typedef getcharbufferproc charbufferproc;
static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
{
  long result = 0;
  PyObject *i = PyNumber_Int(x);
  if (i) {
    result = PyInt_AsLong(i);
    Py_DECREF(i);
  }
  return result;
}
#endif

#if PY_VERSION_HEX < 0x02050000
#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
#endif

#if PY_VERSION_HEX < 0x02040000
#define Py_VISIT(op)				\
  do { 						\
    if (op) {					\
      int vret = visit((op), arg);		\
      if (vret)					\
        return vret;				\
    }						\
  } while (0)
#endif

#if PY_VERSION_HEX < 0x02030000
typedef struct {
  PyTypeObject type;
  PyNumberMethods as_number;
  PyMappingMethods as_mapping;
  PySequenceMethods as_sequence;
  PyBufferProcs as_buffer;
  PyObject *name, *slots;
} PyHeapTypeObject;
#endif

#if PY_VERSION_HEX < 0x02030000
typedef destructor freefunc;
#endif

#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
     (PY_MAJOR_VERSION > 3))
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
#endif

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    char *tmp;
    PyObject *old_str = PyObject_Str(value);
    PyErr_Clear();
    Py_XINCREF(type);

    PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
#      define SWIG_PYTHON_USE_GIL
#    endif
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;


/* -----------------------------------------------------------------------------
 * Wrapper of PyInstanceMethod_New() used in Python 3
 * It is exported to the generated module, used for -fastproxy
 * ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX >= 0x03000000
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
{
  return PyInstanceMethod_New(func);
}
#else
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
{
  return NULL;
}
#endif

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   


/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      PyList_SetItem(result, 0, o2);
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
#else
  PyObject*   o2;
  PyObject*   o3;
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyTuple_Check(result)) {
      o2 = result;
      result = PyTuple_New(1);
      PyTuple_SET_ITEM(result, 0, o2);
    }
    o3 = PyTuple_New(1);
    PyTuple_SET_ITEM(o3, 0, obj);
    o2 = result;
    result = PySequence_Concat(o2, o3);
    Py_DECREF(o2);
    Py_DECREF(o3);
  }
  return result;
#endif
}

/* Unpack the argument tuple */

SWIGINTERN int
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      int i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      int i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

/* A functor is a function object with one single object argument */
#if PY_VERSION_HEX >= 0x02020000
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
#else
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
#endif

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/*  How to access Py_None */
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  ifndef SWIG_PYTHON_NO_BUILD_NONE
#    ifndef SWIG_PYTHON_BUILD_NONE
#      define SWIG_PYTHON_BUILD_NONE
#    endif
#  endif
#endif

#ifdef SWIG_PYTHON_BUILD_NONE
#  ifdef Py_None
#   undef Py_None
#   define Py_None SWIG_Py_None()
#  endif
SWIGRUNTIMEINLINE PyObject * 
_SWIG_Py_None(void)
{
  PyObject *none = Py_BuildValue((char*)"");
  Py_DECREF(none);
  return none;
}
SWIGRUNTIME PyObject * 
SWIG_Py_None(void)
{
  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
  return none;
}
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  return data ? data->implicitconv : 0;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      data->newargs = obj;
      Py_INCREF(obj);
    } else {
#if (PY_VERSION_HEX < 0x02020000)
      data->newraw = 0;
#else
      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
#endif
      if (data->newraw) {
	Py_INCREF(data->newraw);
	data->newargs = PyTuple_New(1);
	PyTuple_SetItem(data->newargs, 0, obj);
      } else {
	data->newargs = obj;
      }
      Py_INCREF(data->newargs);
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      int flags;
      Py_INCREF(data->destroy);
      flags = PyCFunction_GET_FLAGS(data->destroy);
#ifdef METH_O
      data->delargs = !(flags & (METH_O));
#else
      data->delargs = 0;
#endif
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data) {
  Py_XDECREF(data->newraw);
  Py_XDECREF(data->newargs);
  Py_XDECREF(data->destroy);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->dict)
    sobj->dict = PyDict_New();

  Py_INCREF(sobj->dict);
  return sobj->dict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
	res = PyUnicode_Format(ofmt,args);
#else
	res = PyString_Format(ofmt,args);
#endif
	Py_DECREF(ofmt);
      }
      Py_DECREF(args);
    }
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
#ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject *v)
#else
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#endif
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (v->next) {
# ifdef METH_NOARGS
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# else
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
# endif
# if PY_VERSION_HEX >= 0x03000000
    PyObject *joined = PyUnicode_Concat(repr, nrep);
    Py_DecRef(repr);
    Py_DecRef(nrep);
    repr = joined;
# else
    PyString_ConcatAndDel(&repr,nrep);
# endif
  }
  return repr;  
}

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res;
  if( op != Py_EQ && op != Py_NE ) {
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  }
  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  return res;  
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
  PyTypeObject *target_tp = SwigPyObject_type();
  if (PyType_IsSubtype(op->ob_type, target_tp))
    return 1;
  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
  return (Py_TYPE(op) == SwigPyObject_type())
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;
      if (data->delargs) {
	/* we need to create a temporary object to carry the destroy operation */
	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
	res = SWIG_Python_CallFunctor(destroy, tmp);
	Py_DECREF(tmp);
      } else {
	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
	PyObject *mself = PyCFunction_GET_SELF(destroy);
	res = ((*meth)(mself, v));
      }
      Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
  } 
  Py_XDECREF(next);
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
#ifndef METH_O
  PyObject *tmp = 0;
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
  next = tmp;
#endif
  if (!SwigPyObject_Check(next)) {
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
#ifdef METH_NOARGS
SwigPyObject_next(PyObject* v)
#else
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_disown(PyObject *v)
#else
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_acquire(PyObject *v)
#else
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
#if (PY_VERSION_HEX < 0x02020000)
  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#elif (PY_VERSION_HEX < 0x02050000)
  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
#else
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
#endif
    {
      return NULL;
    } 
  else
    {
      SwigPyObject *sobj = (SwigPyObject *)v;
      PyObject *obj = PyBool_FromLong(sobj->own);
      if (val) {
#ifdef METH_NOARGS
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v);
	} else {
	  SwigPyObject_disown(v);
	}
#else
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v,args);
	} else {
	  SwigPyObject_disown(v,args);
	}
#endif
      } 
      return obj;
    }
}

#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#else
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#endif

#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";

  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
      /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      (char *)"SwigPyObject",               /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
      0,				    /* tp_print */
#if PY_VERSION_HEX < 0x02020000
      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
#else
      (getattrfunc)0,                       /* tp_getattr */
#endif
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,				    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      swigobject_methods,                   /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
      0,                                    /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                    /* tp_version */
#endif
#ifdef COUNT_ALLOCS
      0,0,0,0                               /* tp_alloc -> tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    swigpyobject_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpyobject_type) < 0)
      return NULL;
#endif
  }
  return &swigpyobject_type;
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME int
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
  char result[SWIG_BUFFER_SIZE];
  fputs("<Swig Packed ", fp); 
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    fputs("at ", fp); 
    fputs(result, fp); 
  }
  fputs(v->ty->name,fp); 
  fputs(">", fp);
  return 0; 
}
  
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_DEL(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
      /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      (char *)"SwigPyPacked",               /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      (printfunc)SwigPyPacked_print,        /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigpacked_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
      0,                                    /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                    /* tp_version */
#endif
#ifdef COUNT_ALLOCS
      0,0,0,0                               /* tp_alloc -> tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    swigpypacked_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpypacked_type) < 0)
      return NULL;
#endif
  }
  return &swigpypacked_type;
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_DEL((PyObject *) sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
    return SWIG_Python_str_FromChar("this");
}

static PyObject *swig_this = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (swig_this == NULL)
    swig_this = _SWIG_This();
  return swig_this;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
    pyobj = PyWeakref_GET_OBJECT(pyobj);
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  return NULL;
#else

  obj = 0;

#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      obj = PyObject_GetAttr(pyobj,SWIG_This());
      if (obj) {
	Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (own)
      *own = *own | sobj->own;
    if (flags & SWIG_POINTER_DISOWN) {
      sobj->own = 0;
    }
    res = SWIG_OK;
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            Py_DECREF(impconv);
          }
        }
      }
    }
    if (!SWIG_IsOK(res) && obj == Py_None) {
      if (ptr)
        *ptr = 0;
      if (PyErr_Occurred())
        PyErr_Clear();
      res = SWIG_OK;
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    
    /* here we get the method pointer for callbacks */
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    if (!desc) 
      return SWIG_ERROR;
    if (ty) {
      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
      if (tc) {
        int newmemory = 0;
        *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
        assert(!newmemory); /* newmemory handling not yet implemented */
      } else {
        return SWIG_ERROR;
      }
    } else {
      *ptr = vptr;
    }
    return SWIG_OK;
  }
}

/* Convert a packed value value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
#if (PY_VERSION_HEX >= 0x02020000)
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
	PyObject *dict = *dictptr;
	if (dict == NULL) {
	  dict = PyDict_New();
	  *dictptr = dict;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      PyObject *key = SWIG_This();
      PyObject_SetAttr(inst, key, swig_this);
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    if (inst) {
      PyObject_SetAttr(inst, SWIG_This(), swig_this);
      Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
#else
#if (PY_VERSION_HEX >= 0x02010000)
  PyObject *inst = 0;
  PyObject *dict = PyDict_New();
  if (dict) {
    PyDict_SetItem(dict, SWIG_This(), swig_this);
    inst = PyInstance_NewRaw(data->newargs, dict);
    Py_DECREF(dict);
  }
  return (PyObject *) inst;
#else
  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
  if (inst == NULL) {
    return NULL;
  }
  inst->in_class = (PyClassObject *)data->newargs;
  Py_INCREF(inst->in_class);
  inst->in_dict = PyDict_New();
  if (inst->in_dict == NULL) {
    Py_DECREF(inst);
    return NULL;
  }
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
  inst->in_weakreflist = NULL;
#endif
#ifdef Py_TPFLAGS_GC
  PyObject_GC_Init(inst);
#endif
  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
  return (PyObject *) inst;
#endif
#endif
}

SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
 PyObject *dict;
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
 PyObject **dictptr = _PyObject_GetDictPtr(inst);
 if (dictptr != NULL) {
   dict = *dictptr;
   if (dict == NULL) {
     dict = PyDict_New();
     *dictptr = dict;
   }
   PyDict_SetItem(dict, SWIG_This(), swig_this);
   return;
 }
#endif
 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
 PyDict_SetItem(dict, SWIG_This(), swig_this);
 Py_DECREF(dict);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SwigPyObject_append((PyObject*) sthis, obj[1]);
    } else {
      SWIG_Python_SetSwigThis(obj[0], obj[1]);
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
      newobj->dict = 0;
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
# ifdef SWIGPY_USE_CAPSULE
    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
# else
    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
# endif
    if (PyErr_Occurred()) {
      PyErr_Clear();
      type_pointer = (void *)0;
    }
#endif
  }
  return (swig_module_info *) type_pointer;
}

#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
   is copied out of Python/modsupport.c in python version 2.3.4 */
SWIGINTERN int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
  PyObject *dict;
  if (!PyModule_Check(m)) {
    PyErr_SetString(PyExc_TypeError,
		    "PyModule_AddObject() needs module as first arg");
    return SWIG_ERROR;
  }
  if (!o) {
    PyErr_SetString(PyExc_TypeError,
		    "PyModule_AddObject() needs non-NULL value");
    return SWIG_ERROR;
  }
  
  dict = PyModule_GetDict(m);
  if (dict == NULL) {
    /* Internal error -- modules must have a dict! */
    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
		 PyModule_GetName(m));
    return SWIG_ERROR;
  }
  if (PyDict_SetItemString(dict, name, o))
    return SWIG_ERROR;
  Py_DECREF(o);
  return SWIG_OK;
}
#endif

SWIGRUNTIME void
#ifdef SWIGPY_USE_CAPSULE
SWIG_Python_DestroyModule(PyObject *obj)
#else
SWIG_Python_DestroyModule(void *vptr)
#endif
{
#ifdef SWIGPY_USE_CAPSULE
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
#else
  swig_module_info *swig_module = (swig_module_info *) vptr;
#endif
  swig_type_info **types = swig_module->types;
  size_t i;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      if (data) SwigPyClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
  swig_this = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
#ifdef SWIGPY_USE_CAPSULE
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
#else
  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
#endif
}

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
  return cache;
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
#ifdef SWIGPY_USE_CAPSULE
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
#else
    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
#endif
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
#ifdef SWIGPY_USE_CAPSULE
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
#else
      obj = PyCObject_FromVoidPtr(descriptor, NULL);
#endif
      PyDict_SetItem(cache, key, obj);
      Py_DECREF(obj);
    }
  }
  Py_DECREF(key);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      char *tmp;
      PyObject *old_str = PyObject_Str(value);
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
      } else {
	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
      }
      SWIG_Python_str_DelForPy3(tmp);
      Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
          SWIG_Python_str_DelForPy3(cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_XDECREF(str);
	return;
      }
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
#if SWIG_POINTER_EXCEPTION
    if (flags) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
#endif
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = obj->ob_type;
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    return -1;
  } else {
    Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) < 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 



  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 


/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_Doub swig_types[0]
#define SWIGTYPE_p_MatDoub swig_types[1]
#define SWIGTYPE_p_VecDoub swig_types[2]
#define SWIGTYPE_p_allocator_type swig_types[3]
#define SWIGTYPE_p_bool swig_types[4]
#define SWIGTYPE_p_char swig_types[5]
#define SWIGTYPE_p_cosmobl__Catalogue swig_types[6]
#define SWIGTYPE_p_cosmobl__ChainMesh swig_types[7]
#define SWIGTYPE_p_cosmobl__ChainMesh1D swig_types[8]
#define SWIGTYPE_p_cosmobl__ChainMesh2D swig_types[9]
#define SWIGTYPE_p_cosmobl__ChainMesh3D swig_types[10]
#define SWIGTYPE_p_cosmobl__ChainMesh_Catalogue swig_types[11]
#define SWIGTYPE_p_cosmobl__Cluster swig_types[12]
#define SWIGTYPE_p_cosmobl__Cosmology swig_types[13]
#define SWIGTYPE_p_cosmobl__Galaxy swig_types[14]
#define SWIGTYPE_p_cosmobl__GenericObject swig_types[15]
#define SWIGTYPE_p_cosmobl__Halo swig_types[16]
#define SWIGTYPE_p_cosmobl__LogNormal swig_types[17]
#define SWIGTYPE_p_cosmobl__Mock swig_types[18]
#define SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation swig_types[19]
#define SWIGTYPE_p_cosmobl__Object swig_types[20]
#define SWIGTYPE_p_cosmobl__Pairs swig_types[21]
#define SWIGTYPE_p_cosmobl__Pairs2D swig_types[22]
#define SWIGTYPE_p_cosmobl__Pairs3D swig_types[23]
#define SWIGTYPE_p_cosmobl__RandomObject swig_types[24]
#define SWIGTYPE_p_cosmobl__ThreePointCorrelation swig_types[25]
#define SWIGTYPE_p_cosmobl__Triplets swig_types[26]
#define SWIGTYPE_p_cosmobl__Triplets2D swig_types[27]
#define SWIGTYPE_p_cosmobl__Triplets3D swig_types[28]
#define SWIGTYPE_p_cosmobl__TwoPointCorrelation swig_types[29]
#define SWIGTYPE_p_cosmobl__glob__CL swig_types[30]
#define SWIGTYPE_p_cosmobl__glob__GSL_f_pars swig_types[31]
#define SWIGTYPE_p_cosmobl__glob__STR_NG swig_types[32]
#define SWIGTYPE_p_cosmobl__glob__STR_SSM swig_types[33]
#define SWIGTYPE_p_cosmobl__glob__STR_SSM_EH swig_types[34]
#define SWIGTYPE_p_cosmobl__glob__STR_grid swig_types[35]
#define SWIGTYPE_p_cosmobl__glob__STR_grid_2D swig_types[36]
#define SWIGTYPE_p_cosmobl__glob__STR_xi swig_types[37]
#define SWIGTYPE_p_cosmobl__glob__STR_xi0K swig_types[38]
#define SWIGTYPE_p_cosmobl__glob__STR_xi0_model swig_types[39]
#define SWIGTYPE_p_cosmobl__glob__STR_xi2D_model swig_types[40]
#define SWIGTYPE_p_cosmobl__glob__STR_xi_EH swig_types[41]
#define SWIGTYPE_p_difference_type swig_types[42]
#define SWIGTYPE_p_double swig_types[43]
#define SWIGTYPE_p_f_double_p_void__double swig_types[44]
#define SWIGTYPE_p_f_p_double_size_t_p_void__double swig_types[45]
#define SWIGTYPE_p_f_q_const__double__double swig_types[46]
#define SWIGTYPE_p_f_q_const__double_q_const__double__double swig_types[47]
#define SWIGTYPE_p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double swig_types[48]
#define SWIGTYPE_p_int swig_types[49]
#define SWIGTYPE_p_long_long swig_types[50]
#define SWIGTYPE_p_p_PyObject swig_types[51]
#define SWIGTYPE_p_short swig_types[52]
#define SWIGTYPE_p_signed_char swig_types[53]
#define SWIGTYPE_p_size_type swig_types[54]
#define SWIGTYPE_p_std__allocatorT_cosmobl__Cluster_t swig_types[55]
#define SWIGTYPE_p_std__allocatorT_cosmobl__Galaxy_t swig_types[56]
#define SWIGTYPE_p_std__allocatorT_cosmobl__GenericObject_t swig_types[57]
#define SWIGTYPE_p_std__allocatorT_cosmobl__Halo_t swig_types[58]
#define SWIGTYPE_p_std__allocatorT_cosmobl__Mock_t swig_types[59]
#define SWIGTYPE_p_std__allocatorT_cosmobl__RandomObject_t swig_types[60]
#define SWIGTYPE_p_std__invalid_argument swig_types[61]
#define SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t swig_types[62]
#define SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t swig_types[63]
#define SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t swig_types[64]
#define SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t swig_types[65]
#define SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t swig_types[66]
#define SWIGTYPE_p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t swig_types[67]
#define SWIGTYPE_p_std__shared_ptrT_void_t swig_types[68]
#define SWIGTYPE_p_std__string swig_types[69]
#define SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t swig_types[70]
#define SWIGTYPE_p_std__vectorT_cosmobl__Cosmology_std__allocatorT_cosmobl__Cosmology_t_t swig_types[71]
#define SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t swig_types[72]
#define SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t swig_types[73]
#define SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t swig_types[74]
#define SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t swig_types[75]
#define SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t swig_types[76]
#define SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t swig_types[77]
#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[78]
#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator swig_types[79]
#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[80]
#define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t swig_types[81]
#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t swig_types[82]
#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t swig_types[83]
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[84]
#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[85]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[86]
#define SWIGTYPE_p_unsigned_char swig_types[87]
#define SWIGTYPE_p_unsigned_int swig_types[88]
#define SWIGTYPE_p_unsigned_long_long swig_types[89]
#define SWIGTYPE_p_unsigned_short swig_types[90]
#define SWIGTYPE_p_value_type swig_types[91]
static swig_type_info *swig_types[93];
static swig_module_info swig_module = {swig_types, 92, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#if (PY_VERSION_HEX <= 0x02000000)
# if !defined(SWIG_PYTHON_CLASSIC)
#  error "This python version requires swig to be run with the '-classic' option"
# endif
#endif

/*-----------------------------------------------
              @(target):= _CosmoBolognaLib.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__CosmoBolognaLib

#else
#  define SWIG_init    init_CosmoBolognaLib

#endif
#define SWIG_name    "_CosmoBolognaLib"

#define SWIGVERSION 0x030007 
#define SWIG_VERSION SWIGVERSION


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(_obj);      
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


#include <stdexcept>


#if defined(__GNUC__)
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
#     define SWIG_STD_NOMODERN_STL
#  endif
#endif


#include <string>


#include <stddef.h>


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#endif


namespace swig {
  struct stop_iteration {
  };

  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }
      
  public:
    virtual ~SwigPyIterator() {}

    // Access iterator method, required by Python
    virtual PyObject *value() const = 0;

    // Forward iterator method, required by Python
    virtual SwigPyIterator *incr(size_t n = 1) = 0;
    
    // Backward iterator method, very common in C++, but not required in Python
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      throw stop_iteration();
    }

    // Random access iterator methods, but not required in Python
    virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }

    virtual bool equal (const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }
    
    // C++ common/needed methods
    virtual SwigPyIterator *copy() const = 0;

    PyObject *next()     
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      PyObject *obj = value();
      incr();       
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
      return obj;     
    }

    /* Make an alias for Python 3.x */
    PyObject *__next__()
    {
      return next();
    }

    PyObject *previous()
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      decr();
      PyObject *obj = value();
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
      return obj;
    }

    SwigPyIterator *advance(ptrdiff_t n)
    {
      return  (n > 0) ?  incr(n) : decr(-n);
    }
      
    bool operator == (const SwigPyIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const SwigPyIterator& x) const
    {
      return ! operator==(x);
    }
      
    SwigPyIterator& operator += (ptrdiff_t n)
    {
      return *advance(n);
    }

    SwigPyIterator& operator -= (ptrdiff_t n)
    {
      return *advance(-n);
    }
      
    SwigPyIterator* operator + (ptrdiff_t n) const
    {
      return copy()->advance(n);
    }

    SwigPyIterator* operator - (ptrdiff_t n) const
    {
      return copy()->advance(-n);
    }
      
    ptrdiff_t operator - (const SwigPyIterator& x) const
    {
      return x.distance(*this);
    }
      
    static swig_type_info* descriptor() {
      static int init = 0;
      static swig_type_info* desc = 0;
      if (!init) {
	desc = SWIG_TypeQuery("swig::SwigPyIterator *");
	init = 1;
      }	
      return desc;
    }    
  };

#if defined(SWIGPYTHON_BUILTIN)
  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
  {
    Py_INCREF(pyself);
    return pyself;
  }
#endif
}


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
  } else if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx = floor(x);
   double cx = ceil(x);
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
#if PY_VERSION_HEX >= 0x03000000
      {
        long v = PyLong_AsLong(obj);
        if (!PyErr_Occurred()) {
          if (v < 0) {
            return SWIG_OverflowError;
          }
        } else {
          PyErr_Clear();
        }
      }
#endif
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  return res;
}


  #define SWIG_From_long   PyLong_FromLong 


SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
  return SWIG_From_long  (static_cast< long >(value));
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, val ? &v : 0);
  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  return res;
}


#include <algorithm>


#include <vector>


#include <utility>


#include <map>


#include <algorithm>


#include <stdint.h>		// Use the C99 official header


SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}


#include "Func.h"
  
  string cosmobl::par::DirCosmo = "~/CosmoBolognaLib/";
  string cosmobl::par::DirLoc = "./";

  static const double yotta = 1.e24;
  static const double zetta = 1.e21;
  static const double exa = 1.e18;
  static const double peta = 1.e15;
  static const double tera = 1.e12;
  static const double giga = 1.e9;
  static const double mega = 1.e6;
  static const double kilo = 1.e3;
  static const double ecto = 1.e2;
  static const double deca = 10.;
  static const double deci = 1.e-1;
  static const double centi = 1.e-2;
  static const double milli = 1.e-3;
  static const double micro = 1.e-6;
  static const double nano = 1.e-9;
  static const double pico = 1.e-12;
  static const double femto = 1.e-15;
  static const double atto = 1.e-18;
  static const double zepto = 1.e-21;
  static const double yocto = 1.e-24;
  static const char fINT[] = "%i";
  static const char fLONG[] = "%lli";
  static const char fDP0[] = "%1.0f"; 
  static const char fDP1[] = "%2.1f"; 
  static const char fDP2[] = "%3.2f"; 
  static const char fDP3[] = "%4.3f"; 
  static const char fDP4[] = "%5.4f"; 
  static const char fDP5[] = "%6.5f"; 
  static const char fDP6[] = "%7.6f"; 
  static const char ee3[] = "%4.3e";
  static const double pi = 3.1415926535897932;
  static const double ee = 2.7182818284590452;
  static const double hbar = 1.054571726e-3;
  static const double cc = 299792.458;      
  static const double kB = 1.3806488e23;
  static const double sSB = 5.670373e-8;
  static const double el = 1.602176565e-19;
  static const double alpha = 7.2973525698e-3;
  static const double epsilon0 = 8.854187817e-12;
  static const double mu0 = 12.566370614e-7; 
  static const double NAv = 6.02214129e23; 
  static const double GN = 6.6738480e-11;
  static const double gn = 9.80665;
  static const double lP = 1.616199e-35; 
  static const double MP = 2.17651e-8;
  static const double Msol = 1.98855e30;
  static const double me = 9.10938291e-31; 
  static const double mn = 1.674927351e-27; 
  static const double mp = 1.672621777e-27;
  static const double au = 149597870700; 
  static const double pc = 3.0856775814671916e16;
  static const double TCMB = 2.72548;
  static const double yr = 31557600;      
  static const string col_default = "\033[0m";
  static const string col_red = "\033[0;31m";
  static const string col_green = "\033[0;32m";
  static const string col_blue = "\033[0;34m";
  

SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
  if (PyUnicode_Check(obj))
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
#if PY_VERSION_HEX>=0x03000000
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    PyBytes_AsStringAndSize(obj, &cstr, &len);
    if(alloc) *alloc = SWIG_NEWOBJ;
#else
    PyString_AsStringAndSize(obj, &cstr, &len);
#endif
    if (cptr) {
      if (alloc) {
	/* 
	   In python the user should not be able to modify the inner
	   string representation. To warranty that, if you define
	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
	   buffer is always returned.

	   The default behavior is just to return the pointer value,
	   so, be careful.
	*/ 
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
	if (*alloc != SWIG_OLDOBJ) 
#else
	if (*alloc == SWIG_NEWOBJ) 
#endif
	  {
	    *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
	    *alloc = SWIG_NEWOBJ;
	  }
	else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
        #if PY_VERSION_HEX>=0x03000000
        assert(0); /* Should never reach here in Python 3 */
        #endif
	*cptr = SWIG_Python_str_AsChar(obj);
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000
    Py_XDECREF(obj);
#endif
    return SWIG_OK;
  } else {
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    static int init = 0;
    static swig_type_info* descriptor = 0;
    if (!init) {
      descriptor = SWIG_TypeQuery("std::string" " *");
      init = 1;
    }
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


SWIGINTERN int
SWIG_AsVal_short (PyObject * obj, short *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < SHRT_MIN || v > SHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< short >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_short  (short value)
{    
  return SWIG_From_long  (value);
}


SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}


SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    long long v = PyLong_AsLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  } else {
    long v;
    res = SWIG_AsVal_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    const double mant_min = -mant_max;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
      if (val) *val = (long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}


SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyLong_FromLong(static_cast< long >(value)); 
}


/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif


SWIGINTERN int
SWIG_AsVal_float (PyObject * obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if (SWIG_Float_Overflow_Check(v)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}


  #define SWIG_From_double   PyFloat_FromDouble 


SWIGINTERNINLINE PyObject *
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}


SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if PY_VERSION_HEX >= 0x03010000
      return PyUnicode_DecodeUTF8(carray, static_cast< int >(size), "surrogateescape");
#else
      return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< int >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERNINLINE PyObject *
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}


SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


#include "Chain.h"
#include "Prior.h"
#include "Parameter.h"
#include "Model.h"
#include "Data.h"
#include "Chi2.h"


#include "Cosmology.h"


#include "ChainMesh.h"



#include "Object.h"
#include "GenericObject.h"
#include "RandomObject.h"
#include "Halo.h"
#include "Mock.h"
#include "Galaxy.h"
#include "Cluster.h"
#include "Catalogue.h"
#include "ChainMesh_Catalogue.h"



namespace swig {  
  template <class Type>
  struct noconst_traits {
    typedef Type noconst_type;
  };

  template <class Type>
  struct noconst_traits<const Type> {
    typedef Type noconst_type;
  };

  /*
    type categories
  */
  struct pointer_category { };  
  struct value_category { };

  /*
    General traits that provides type_name and type_info
  */
  template <class Type> struct traits { };

  template <class Type>
  inline const char* type_name() {
    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
  }

  template <class Type> 
  struct traits_info {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }    
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  template <class Type>
  inline swig_type_info *type_info() {
    return traits_info<Type>::type_info();
  }

  /*
    Partial specialization for pointers
  */
  template <class Type> struct traits <Type *> {
    typedef pointer_category category;
    static std::string make_ptr_name(const char* name) {
      std::string ptrname = name;
      ptrname += " *";
      return ptrname;
    }    
    static const char* type_name() {
      static std::string name = make_ptr_name(swig::type_name<Type>());
      return name.c_str();
    }
  };

  template <class Type, class Category> 
  struct traits_as { };
 
  template <class Type, class Category> 
  struct traits_check { };

}


namespace swig {  
  /*
    Traits that provides the from method
  */
  template <class Type> struct traits_from_ptr {
    static PyObject *from(Type *val, int owner = 0) {
      return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
    }
  };

  template <class Type> struct traits_from {
    static PyObject *from(const Type& val) {
      return traits_from_ptr<Type>::from(new Type(val), 1);
    }
  };

  template <class Type> struct traits_from<Type *> {
    static PyObject *from(Type* val) {
      return traits_from_ptr<Type>::from(val, 0);
    }
  };

  template <class Type> struct traits_from<const Type *> {
    static PyObject *from(const Type* val) {
      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    }
  };


  template <class Type>
  inline PyObject *from(const Type& val) {
    return traits_from<Type>::from(val);
  }

  template <class Type>
  inline PyObject *from_ptr(Type* val, int owner) {
    return traits_from_ptr<Type>::from(val, owner);
  }

  /*
    Traits that provides the asval/as/check method
  */
  template <class Type>
  struct traits_asptr {   
    static int asptr(PyObject *obj, Type **val) {
      Type *p;
      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
      if (SWIG_IsOK(res)) {
	if (val) *val = p;
      }
      return res;
    }
  }; 

  template <class Type>
  inline int asptr(PyObject *obj, Type **vptr) {
    return traits_asptr<Type>::asptr(obj, vptr);
  }

  template <class Type> 
  struct traits_asval {
    static int asval(PyObject *obj, Type *val) {
      if (val) {
	Type *p = 0;
	int res = traits_asptr<Type>::asptr(obj, &p);
	if (!SWIG_IsOK(res)) return res;	
	if (p) {
	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
	  *(const_cast<noconst_type*>(val)) = *p;
	  if (SWIG_IsNewObj(res)){
	    delete p;
	    res = SWIG_DelNewMask(res);
	  }
	  return res;
	} else {
	  return SWIG_ERROR;
	}
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };

  template <class Type> struct traits_asval<Type*> {
    static int asval(PyObject *obj, Type **val) {
      if (val) {
        typedef typename noconst_traits<Type>::noconst_type noconst_type;
        noconst_type *p = 0;
        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
        if (SWIG_IsOK(res)) {
          *(const_cast<noconst_type**>(val)) = p;
	}
	return res;
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };
  
  template <class Type>
  inline int asval(PyObject *obj, Type *val) {
    return traits_asval<Type>::asval(obj, val);
  }

  template <class Type> 
  struct traits_as<Type, value_category> {
    static Type as(PyObject *obj, bool throw_error) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj, bool throw_error) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res) && v) {
	if (SWIG_IsNewObj(res)) {
	  Type r(*v);
	  delete v;
	  return r;
	} else {
	  return *v;
	}
      } else {
	// Uninitialized return value, no Type() constructor required.
	static Type *v_def = (Type*) malloc(sizeof(Type));
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
	memset(v_def,0,sizeof(Type));
	return *v_def;
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(PyObject *obj, bool throw_error) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res)) {
	return v;
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
	return 0;
      }
    }
  };
    
  template <class Type>
  inline Type as(PyObject *obj, bool te = false) {
    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
  }

  template <class Type> 
  struct traits_check<Type, value_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type> 
  struct traits_check<Type, pointer_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type>
  inline bool check(PyObject *obj) {
    return traits_check<Type, typename traits<Type>::category>::check(obj);
  }
}


#include <functional>

namespace std {
  template <>
  struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
  {
    bool
    operator()(PyObject * v, PyObject *w) const
    { 
      bool res;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
      /* This may fall into a case of inconsistent
               eg. ObjA > ObjX > ObjB
               but ObjA < ObjB
      */
      if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
      {
        /* Objects can't be compared, this mostly occurred in Python 3.0 */
        /* Compare their ptr directly for a workaround */
        res = (v < w);
        PyErr_Clear();
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return res;
    }
  };

  template <>
  struct less <swig::SwigPtr_PyObject>: public binary_function<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject, bool>
  {
    bool
    operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
    {
      return std::less<PyObject *>()(v, w);
    }
  };

  template <>
  struct less <swig::SwigVar_PyObject>: public binary_function<swig::SwigVar_PyObject, swig::SwigVar_PyObject, bool>
  {
    bool
    operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
    {
      return std::less<PyObject *>()(v, w);
    }
  };

}

namespace swig {
  template <> struct traits<PyObject *> {
    typedef value_category category;
    static const char* type_name() { return "PyObject *"; }
  };  

  template <>  struct traits_asval<PyObject * > {   
    typedef PyObject * value_type;
    static int asval(PyObject *obj, value_type *val) {
      if (val) *val = obj;
      return SWIG_OK;
    }
  };

  template <> 
  struct traits_check<PyObject *, value_category> {
    static bool check(PyObject *) {
      return true;
    }
  };

  template <>  struct traits_from<PyObject *> {
    typedef PyObject * value_type;
    static PyObject *from(const value_type& val) {
      Py_XINCREF(val);
      return val;
    }
  };
  
}

namespace swig {
  template <class Difference>
  inline size_t
  check_index(Difference i, size_t size, bool insert = false) {
    if ( i < 0 ) {
      if ((size_t) (-i) <= size)
	return (size_t) (i + size);
    } else if ( (size_t) i < size ) {
      return (size_t) i;
    } else if (insert && ((size_t) i == size)) {
      return size;
    }
    throw std::out_of_range("index out of range");
  }

  template <class Difference>
  void
  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
    if (step == 0) {
      throw std::invalid_argument("slice step cannot be zero");
    } else if (step > 0) {
      // Required range: 0 <= i < size, 0 <= j < size
      if (i < 0) {
        ii = 0;
      } else if (i < (Difference)size) {
        ii = i;
      } else if (insert && (i >= (Difference)size)) {
        ii = (Difference)size;
      }
      if ( j < 0 ) {
        jj = 0;
      } else {
        jj = (j < (Difference)size) ? j : (Difference)size;
      }
    } else {
      // Required range: -1 <= i < size-1, -1 <= j < size-1
      if (i < -1) {
        ii = -1;
      } else if (i < (Difference) size) {
        ii = i;
      } else if (i >= (Difference)(size-1)) {
        ii = (Difference)(size-1);
      }
      if (j < -1) {
        jj = -1;
      } else {
        jj = (j < (Difference)size ) ? j : (Difference)(size-1);
      }
    }
  }

  template <class Sequence, class Difference>
  inline typename Sequence::iterator
  getpos(Sequence* self, Difference i)  {
    typename Sequence::iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence, class Difference>
  inline typename Sequence::const_iterator
  cgetpos(const Sequence* self, Difference i)  {
    typename Sequence::const_iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence, class Difference>
  inline Sequence*
  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj);

    if (step > 0) {
      typename Sequence::const_iterator sb = self->begin();
      typename Sequence::const_iterator se = self->begin();
      std::advance(sb,ii);
      std::advance(se,jj);
      if (step == 1) {
        return new Sequence(sb, se);
      } else {
        Sequence *sequence = new Sequence();
        typename Sequence::const_iterator it = sb;
        while (it!=se) {
          sequence->push_back(*it);
          for (Py_ssize_t c=0; c<step && it!=se; ++c)
            it++;
        }
        return sequence;
      } 
    } else {
      Sequence *sequence = new Sequence();
      if (ii > jj) {
        typename Sequence::const_reverse_iterator sb = self->rbegin();
        typename Sequence::const_reverse_iterator se = self->rbegin();
        std::advance(sb,size-ii-1);
        std::advance(se,size-jj-1);
        typename Sequence::const_reverse_iterator it = sb;
        while (it!=se) {
          sequence->push_back(*it);
          for (Py_ssize_t c=0; c<-step && it!=se; ++c)
            it++;
        }
      }
      return sequence;
    }
  }

  template <class Sequence, class Difference, class InputSeq>
  inline void
  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj, true);
    if (step > 0) {
      if (jj < ii)
        jj = ii;
      if (step == 1) {
        size_t ssize = jj - ii;
        if (ssize <= is.size()) {
          // expanding/staying the same size
          typename Sequence::iterator sb = self->begin();
          typename InputSeq::const_iterator isit = is.begin();
          std::advance(sb,ii);
          std::advance(isit, jj - ii);
          self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
        } else {
          // shrinking
          typename Sequence::iterator sb = self->begin();
          typename Sequence::iterator se = self->begin();
          std::advance(sb,ii);
          std::advance(se,jj);
          self->erase(sb,se);
          sb = self->begin();
          std::advance(sb,ii);
          self->insert(sb, is.begin(), is.end());
        }
      } else {
        size_t replacecount = (jj - ii + step - 1) / step;
        if (is.size() != replacecount) {
          char msg[1024];
          sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
          throw std::invalid_argument(msg);
        }
        typename Sequence::const_iterator isit = is.begin();
        typename Sequence::iterator it = self->begin();
        std::advance(it,ii);
        for (size_t rc=0; rc<replacecount; ++rc) {
          *it++ = *isit++;
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
        }
      }
    } else {
      if (jj > ii)
        jj = ii;
      size_t replacecount = (ii - jj - step - 1) / -step;
      if (is.size() != replacecount) {
        char msg[1024];
        sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
        throw std::invalid_argument(msg);
      }
      typename Sequence::const_iterator isit = is.begin();
      typename Sequence::reverse_iterator it = self->rbegin();
      std::advance(it,size-ii-1);
      for (size_t rc=0; rc<replacecount; ++rc) {
        *it++ = *isit++;
        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
          it++;
      }
    }
  }

  template <class Sequence, class Difference>
  inline void
  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj, true);
    if (step > 0) {
      if (jj > ii) {
        typename Sequence::iterator sb = self->begin();
        std::advance(sb,ii);
        if (step == 1) {
          typename Sequence::iterator se = self->begin();
          std::advance(se,jj);
          self->erase(sb,se);
        } else {
          typename Sequence::iterator it = sb;
          size_t delcount = (jj - ii + step - 1) / step;
          while (delcount) {
            it = self->erase(it);
            for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
              it++;
            delcount--;
          }
        }
      }
    } else {
      if (ii > jj) {
        typename Sequence::reverse_iterator sb = self->rbegin();
        std::advance(sb,size-ii-1);
        typename Sequence::reverse_iterator it = sb;
        size_t delcount = (ii - jj - step - 1) / -step;
        while (delcount) {
          it = typename Sequence::reverse_iterator(self->erase((++it).base()));
          for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
            it++;
          delcount--;
        }
      }
    }
  }
}


#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
#  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
#    define SWIG_STD_NOITERATOR_TRAITS_STL
#  endif
#endif

#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
#include <iterator>
#else
namespace std {
  template <class Iterator>
  struct iterator_traits {
    typedef ptrdiff_t difference_type;
    typedef typename Iterator::value_type value_type;
  };

  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
    typedef Distance difference_type;
    typedef T value_type;
  };

  template <class T>
  struct iterator_traits<T*> {
    typedef T value_type;
    typedef ptrdiff_t difference_type;
  };

  template<typename _InputIterator>
  inline typename iterator_traits<_InputIterator>::difference_type
  distance(_InputIterator __first, _InputIterator __last)
  {
    typename iterator_traits<_InputIterator>::difference_type __n = 0;
    while (__first != __last) {
      ++__first; ++__n;
    }
    return __n;
  }
}
#endif


namespace swig {
  template<typename OutIterator>
  class SwigPyIterator_T :  public SwigPyIterator
  {
  public:
    typedef OutIterator out_iterator;
    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
    typedef SwigPyIterator_T<out_iterator> self_type;

    SwigPyIterator_T(out_iterator curr, PyObject *seq)
      : SwigPyIterator(seq), current(curr)
    {
    }

    const out_iterator& get_current() const
    {
      return current;
    }

    
    bool equal (const SwigPyIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return (current == iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }
    
    ptrdiff_t distance(const SwigPyIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return std::distance(current, iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }    
    
  protected:
    out_iterator current;
  };
  
  template <class ValueType>
  struct from_oper 
  {
    typedef const ValueType& argument_type;
    typedef PyObject *result_type;
    result_type operator()(argument_type v) const
    {
      return swig::from(v);
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
      : SwigPyIterator_T<OutIterator>(curr, seq)
    {
    }
    
    PyObject *value() const {
      return from(static_cast<const value_type&>(*(base::current)));
    }
    
    SwigPyIterator *copy() const
    {
      return new self_type(*this);
    }

    SwigPyIterator *incr(size_t n = 1)
    {
      while (n--) {
	++base::current;
      }
      return this;
    }

    SwigPyIterator *decr(size_t n = 1)
    {
      while (n--) {
	--base::current;
      }
      return this;
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;    
    typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
      : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
    {
    }
    
    PyObject *value() const {
      if (base::current == end) {
	throw stop_iteration();
      } else {
	return from(static_cast<const value_type&>(*(base::current)));
      }
    }
    
    SwigPyIterator *copy() const
    {
      return new self_type(*this);
    }

    SwigPyIterator *incr(size_t n = 1)
    {
      while (n--) {
	if (base::current == end) {
	  throw stop_iteration();
	} else {
	  ++base::current;
	}
      }
      return this;
    }

    SwigPyIterator *decr(size_t n = 1)
    {
      while (n--) {
	if (base::current == begin) {
	  throw stop_iteration();
	} else {
	  --base::current;
	}
      }
      return this;
    }

  private:
    out_iterator begin;
    out_iterator end;
  };

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
  {
    return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyIteratorOpen_T<OutIter>(current, seq);
  }

}


namespace swig
{
  template <class T>
  struct SwigPySequence_Ref
  {
    SwigPySequence_Ref(PyObject* seq, int index)
      : _seq(seq), _index(index)
    {
    }
    
    operator T () const
    {
      swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
      try {
	return swig::as<T>(item, true);
      } catch (std::exception& e) {
	char msg[1024];
	sprintf(msg, "in sequence element %d ", _index);
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
	}
	SWIG_Python_AddErrorMsg(msg);
	SWIG_Python_AddErrorMsg(e.what());
	throw;
      }
    }

    SwigPySequence_Ref& operator=(const T& v)
    {
      PySequence_SetItem(_seq, _index, swig::from<T>(v));
      return *this;
    }

  private:
    PyObject* _seq;
    int _index;
  };

  template <class T>
  struct SwigPySequence_ArrowProxy
  {
    SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
    const T* operator->() const { return &m_value; }
    operator const T*() const { return &m_value; }
    T m_value;
  };

  template <class T, class Reference >
  struct SwigPySequence_InputIterator
  {
    typedef SwigPySequence_InputIterator<T, Reference > self;

    typedef std::random_access_iterator_tag iterator_category;
    typedef Reference reference;
    typedef T value_type;
    typedef T* pointer;
    typedef int difference_type;

    SwigPySequence_InputIterator()
    {
    }

    SwigPySequence_InputIterator(PyObject* seq, int index)
      : _seq(seq), _index(index)
    {
    }

    reference operator*() const
    {
      return reference(_seq, _index);
    }

    SwigPySequence_ArrowProxy<T>
    operator->() const {
      return SwigPySequence_ArrowProxy<T>(operator*());
    }

    bool operator==(const self& ri) const
    {
      return (_index == ri._index) && (_seq == ri._seq);
    }

    bool operator!=(const self& ri) const
    {
      return !(operator==(ri));
    }

    self& operator ++ ()
    {
      ++_index;
      return *this;
    }

    self& operator -- ()
    {
      --_index;
      return *this;
    }

    self& operator += (difference_type n)
    {
      _index += n;
      return *this;
    }

    self operator +(difference_type n) const
    {
      return self(_seq, _index + n);
    }

    self& operator -= (difference_type n)
    {
      _index -= n;
      return *this;
    }

    self operator -(difference_type n) const
    {
      return self(_seq, _index - n);
    }

    difference_type operator - (const self& ri) const
    {
      return _index - ri._index;
    }

    bool operator < (const self& ri) const
    {
      return _index < ri._index;
    }

    reference
    operator[](difference_type n) const
    {
      return reference(_seq, _index + n);
    }

  private:
    PyObject* _seq;
    difference_type _index;
  };

  template <class T>
  struct SwigPySequence_Cont
  {
    typedef SwigPySequence_Ref<T> reference;
    typedef const SwigPySequence_Ref<T> const_reference;
    typedef T value_type;
    typedef T* pointer;
    typedef int difference_type;
    typedef int size_type;
    typedef const pointer const_pointer;
    typedef SwigPySequence_InputIterator<T, reference> iterator;
    typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;

    SwigPySequence_Cont(PyObject* seq) : _seq(0)
    {
      if (!PySequence_Check(seq)) {
	throw std::invalid_argument("a sequence is expected");
      }
      _seq = seq;
      Py_INCREF(_seq);
    }

    ~SwigPySequence_Cont()
    {
      Py_XDECREF(_seq);
    }

    size_type size() const
    {
      return static_cast<size_type>(PySequence_Size(_seq));
    }

    bool empty() const
    {
      return size() == 0;
    }

    iterator begin()
    {
      return iterator(_seq, 0);
    }

    const_iterator begin() const
    {
      return const_iterator(_seq, 0);
    }

    iterator end()
    {
      return iterator(_seq, size());
    }

    const_iterator end() const
    {
      return const_iterator(_seq, size());
    }

    reference operator[](difference_type n)
    {
      return reference(_seq, n);
    }

    const_reference operator[](difference_type n)  const
    {
      return const_reference(_seq, n);
    }

    bool check(bool set_err = true) const
    {
      int s = size();
      for (int i = 0; i < s; ++i) {
	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
	if (!swig::check<value_type>(item)) {
	  if (set_err) {
	    char msg[1024];
	    sprintf(msg, "in sequence element %d", i);
	    SWIG_Error(SWIG_RuntimeError, msg);
	  }
	  return false;
	}
      }
      return true;
    }

  private:
    PyObject* _seq;
  };

}

SWIGINTERN swig::SwigPyIterator *vector_Sl_cosmobl_GenericObject_Sg__iterator(vector< cosmobl::GenericObject > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool vector_Sl_cosmobl_GenericObject_Sg____nonzero__(vector< cosmobl::GenericObject > const *self){
      return !(self->empty());
    }
SWIGINTERN bool vector_Sl_cosmobl_GenericObject_Sg____bool__(vector< cosmobl::GenericObject > const *self){
      return !(self->empty());
    }
SWIGINTERN vector< cosmobl::GenericObject >::size_type vector_Sl_cosmobl_GenericObject_Sg____len__(vector< cosmobl::GenericObject > const *self){
      return self->size();
    }

SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyLong_FromLong(static_cast< long >(value)); 
}


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
  return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
}

SWIGINTERN vector< cosmobl::GenericObject >::value_type vector_Sl_cosmobl_GenericObject_Sg__pop(vector< cosmobl::GenericObject > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *vector_Sl_cosmobl_GenericObject_Sg____getslice__(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::difference_type i,vector< cosmobl::GenericObject >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }

  namespace swig {
    template <>  struct traits<cosmobl::GenericObject > {
      typedef pointer_category category;
      static const char* type_name() { return"cosmobl::GenericObject"; }
    };
  }


namespace swig {
  template <class SwigPySeq, class Seq>
  inline void
  assign(const SwigPySeq& swigpyseq, Seq* seq) {
    // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
    typedef typename SwigPySeq::value_type value_type;
    typename SwigPySeq::const_iterator it = swigpyseq.begin();
    for (;it != swigpyseq.end(); ++it) {
      seq->insert(seq->end(),(value_type)(*it));
    }
  }

  template <class Seq, class T = typename Seq::value_type >
  struct traits_asptr_stdseq {
    typedef Seq sequence;
    typedef T value_type;

    static int asptr(PyObject *obj, sequence **seq) {
      if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
	sequence *p;
	if (::SWIG_ConvertPtr(obj,(void**)&p,
			      swig::type_info<sequence>(),0) == SWIG_OK) {
	  if (seq) *seq = p;
	  return SWIG_OLDOBJ;
	}
      } else if (PySequence_Check(obj)) {
	try {
	  SwigPySequence_Cont<value_type> swigpyseq(obj);
	  if (seq) {
	    sequence *pseq = new sequence();
	    assign(swigpyseq, pseq);
	    *seq = pseq;
	    return SWIG_NEWOBJ;
	  } else {
	    return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
	  }
	} catch (std::exception& e) {
	  if (seq) {
	    if (!PyErr_Occurred()) {
	      PyErr_SetString(PyExc_TypeError, e.what());
	    }
	  }
	  return SWIG_ERROR;
	}
      }
      return SWIG_ERROR;
    }
  };

  template <class Seq, class T = typename Seq::value_type >
  struct traits_from_stdseq {
    typedef Seq sequence;
    typedef T value_type;
    typedef typename Seq::size_type size_type;
    typedef typename sequence::const_iterator const_iterator;

    static PyObject *from(const sequence& seq) {
#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
      swig_type_info *desc = swig::type_info<sequence>();
      if (desc && desc->clientdata) {
	return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
      }
#endif
      size_type size = seq.size();
      if (size <= (size_type)INT_MAX) {
	PyObject *obj = PyTuple_New((int)size);
	int i = 0;
	for (const_iterator it = seq.begin();
	     it != seq.end(); ++it, ++i) {
	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
	}
	return obj;
      } else {
	PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
	return NULL;
      }
    }
  };
}


  namespace swig {
    template <class T>
    struct traits_asptr<std::vector<T> >  {
      static int asptr(PyObject *obj, std::vector<T> **vec) {
	return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
      }
    };
    
    template <class T>
    struct traits_from<std::vector<T> > {
      static PyObject *from(const std::vector<T>& vec) {
	return traits_from_stdseq<std::vector<T> >::from(vec);
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector<cosmobl::GenericObject, std::allocator< cosmobl::GenericObject > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "cosmobl::GenericObject" "," "std::allocator< cosmobl::GenericObject >" " >";
	  }
	};
      }
    
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg____setslice____SWIG_0(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::difference_type i,vector< cosmobl::GenericObject >::difference_type j,std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &v=std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >()){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg____delslice__(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::difference_type i,vector< cosmobl::GenericObject >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg____delitem____SWIG_0(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::difference_type i){
      self->erase(swig::getpos(self,i));
    }
SWIGINTERN std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *vector_Sl_cosmobl_GenericObject_Sg____getitem____SWIG_0(vector< cosmobl::GenericObject > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::difference_type id = i;
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg____setitem____SWIG_0(vector< cosmobl::GenericObject > *self,PySliceObject *slice,std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::difference_type id = i;
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg____setitem____SWIG_1(vector< cosmobl::GenericObject > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::difference_type id = i;
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg____delitem____SWIG_1(vector< cosmobl::GenericObject > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::difference_type id = i;
      std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN vector< cosmobl::GenericObject >::value_type const &vector_Sl_cosmobl_GenericObject_Sg____getitem____SWIG_1(vector< cosmobl::GenericObject > const *self,vector< cosmobl::GenericObject >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg____setitem____SWIG_2(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::difference_type i,vector< cosmobl::GenericObject >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg__append(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN vector< cosmobl::GenericObject >::iterator vector_Sl_cosmobl_GenericObject_Sg__erase__SWIG_0(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::iterator pos){ return self->erase(pos); }
SWIGINTERN vector< cosmobl::GenericObject >::iterator vector_Sl_cosmobl_GenericObject_Sg__erase__SWIG_1(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::iterator first,vector< cosmobl::GenericObject >::iterator last){ return self->erase(first, last); }
SWIGINTERN vector< cosmobl::GenericObject >::iterator vector_Sl_cosmobl_GenericObject_Sg__insert__SWIG_0(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::iterator pos,vector< cosmobl::GenericObject >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void vector_Sl_cosmobl_GenericObject_Sg__insert__SWIG_1(vector< cosmobl::GenericObject > *self,vector< cosmobl::GenericObject >::iterator pos,vector< cosmobl::GenericObject >::size_type n,vector< cosmobl::GenericObject >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN swig::SwigPyIterator *vector_Sl_cosmobl_RandomObject_Sg__iterator(vector< cosmobl::RandomObject > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool vector_Sl_cosmobl_RandomObject_Sg____nonzero__(vector< cosmobl::RandomObject > const *self){
      return !(self->empty());
    }
SWIGINTERN bool vector_Sl_cosmobl_RandomObject_Sg____bool__(vector< cosmobl::RandomObject > const *self){
      return !(self->empty());
    }
SWIGINTERN vector< cosmobl::RandomObject >::size_type vector_Sl_cosmobl_RandomObject_Sg____len__(vector< cosmobl::RandomObject > const *self){
      return self->size();
    }
SWIGINTERN vector< cosmobl::RandomObject >::value_type vector_Sl_cosmobl_RandomObject_Sg__pop(vector< cosmobl::RandomObject > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *vector_Sl_cosmobl_RandomObject_Sg____getslice__(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::difference_type i,vector< cosmobl::RandomObject >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }

  namespace swig {
    template <>  struct traits<cosmobl::RandomObject > {
      typedef pointer_category category;
      static const char* type_name() { return"cosmobl::RandomObject"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector<cosmobl::RandomObject, std::allocator< cosmobl::RandomObject > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "cosmobl::RandomObject" "," "std::allocator< cosmobl::RandomObject >" " >";
	  }
	};
      }
    
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg____setslice____SWIG_0(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::difference_type i,vector< cosmobl::RandomObject >::difference_type j,std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &v=std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >()){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg____delslice__(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::difference_type i,vector< cosmobl::RandomObject >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg____delitem____SWIG_0(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::difference_type i){
      self->erase(swig::getpos(self,i));
    }
SWIGINTERN std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *vector_Sl_cosmobl_RandomObject_Sg____getitem____SWIG_0(vector< cosmobl::RandomObject > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::difference_type id = i;
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg____setitem____SWIG_0(vector< cosmobl::RandomObject > *self,PySliceObject *slice,std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::difference_type id = i;
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg____setitem____SWIG_1(vector< cosmobl::RandomObject > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::difference_type id = i;
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg____delitem____SWIG_1(vector< cosmobl::RandomObject > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::difference_type id = i;
      std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN vector< cosmobl::RandomObject >::value_type const &vector_Sl_cosmobl_RandomObject_Sg____getitem____SWIG_1(vector< cosmobl::RandomObject > const *self,vector< cosmobl::RandomObject >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg____setitem____SWIG_2(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::difference_type i,vector< cosmobl::RandomObject >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg__append(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN vector< cosmobl::RandomObject >::iterator vector_Sl_cosmobl_RandomObject_Sg__erase__SWIG_0(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::iterator pos){ return self->erase(pos); }
SWIGINTERN vector< cosmobl::RandomObject >::iterator vector_Sl_cosmobl_RandomObject_Sg__erase__SWIG_1(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::iterator first,vector< cosmobl::RandomObject >::iterator last){ return self->erase(first, last); }
SWIGINTERN vector< cosmobl::RandomObject >::iterator vector_Sl_cosmobl_RandomObject_Sg__insert__SWIG_0(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::iterator pos,vector< cosmobl::RandomObject >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void vector_Sl_cosmobl_RandomObject_Sg__insert__SWIG_1(vector< cosmobl::RandomObject > *self,vector< cosmobl::RandomObject >::iterator pos,vector< cosmobl::RandomObject >::size_type n,vector< cosmobl::RandomObject >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN swig::SwigPyIterator *vector_Sl_cosmobl_Mock_Sg__iterator(vector< cosmobl::Mock > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool vector_Sl_cosmobl_Mock_Sg____nonzero__(vector< cosmobl::Mock > const *self){
      return !(self->empty());
    }
SWIGINTERN bool vector_Sl_cosmobl_Mock_Sg____bool__(vector< cosmobl::Mock > const *self){
      return !(self->empty());
    }
SWIGINTERN vector< cosmobl::Mock >::size_type vector_Sl_cosmobl_Mock_Sg____len__(vector< cosmobl::Mock > const *self){
      return self->size();
    }
SWIGINTERN vector< cosmobl::Mock >::value_type vector_Sl_cosmobl_Mock_Sg__pop(vector< cosmobl::Mock > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *vector_Sl_cosmobl_Mock_Sg____getslice__(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::difference_type i,vector< cosmobl::Mock >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }

  namespace swig {
    template <>  struct traits<cosmobl::Mock > {
      typedef pointer_category category;
      static const char* type_name() { return"cosmobl::Mock"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector<cosmobl::Mock, std::allocator< cosmobl::Mock > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "cosmobl::Mock" "," "std::allocator< cosmobl::Mock >" " >";
	  }
	};
      }
    
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg____setslice____SWIG_0(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::difference_type i,vector< cosmobl::Mock >::difference_type j,std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &v=std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > >()){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg____delslice__(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::difference_type i,vector< cosmobl::Mock >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg____delitem____SWIG_0(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::difference_type i){
      self->erase(swig::getpos(self,i));
    }
SWIGINTERN std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *vector_Sl_cosmobl_Mock_Sg____getitem____SWIG_0(vector< cosmobl::Mock > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::difference_type id = i;
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg____setitem____SWIG_0(vector< cosmobl::Mock > *self,PySliceObject *slice,std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::difference_type id = i;
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg____setitem____SWIG_1(vector< cosmobl::Mock > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::difference_type id = i;
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg____delitem____SWIG_1(vector< cosmobl::Mock > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::difference_type id = i;
      std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN vector< cosmobl::Mock >::value_type const &vector_Sl_cosmobl_Mock_Sg____getitem____SWIG_1(vector< cosmobl::Mock > const *self,vector< cosmobl::Mock >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg____setitem____SWIG_2(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::difference_type i,vector< cosmobl::Mock >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg__append(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN vector< cosmobl::Mock >::iterator vector_Sl_cosmobl_Mock_Sg__erase__SWIG_0(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::iterator pos){ return self->erase(pos); }
SWIGINTERN vector< cosmobl::Mock >::iterator vector_Sl_cosmobl_Mock_Sg__erase__SWIG_1(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::iterator first,vector< cosmobl::Mock >::iterator last){ return self->erase(first, last); }
SWIGINTERN vector< cosmobl::Mock >::iterator vector_Sl_cosmobl_Mock_Sg__insert__SWIG_0(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::iterator pos,vector< cosmobl::Mock >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void vector_Sl_cosmobl_Mock_Sg__insert__SWIG_1(vector< cosmobl::Mock > *self,vector< cosmobl::Mock >::iterator pos,vector< cosmobl::Mock >::size_type n,vector< cosmobl::Mock >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN swig::SwigPyIterator *vector_Sl_cosmobl_Halo_Sg__iterator(vector< cosmobl::Halo > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool vector_Sl_cosmobl_Halo_Sg____nonzero__(vector< cosmobl::Halo > const *self){
      return !(self->empty());
    }
SWIGINTERN bool vector_Sl_cosmobl_Halo_Sg____bool__(vector< cosmobl::Halo > const *self){
      return !(self->empty());
    }
SWIGINTERN vector< cosmobl::Halo >::size_type vector_Sl_cosmobl_Halo_Sg____len__(vector< cosmobl::Halo > const *self){
      return self->size();
    }
SWIGINTERN vector< cosmobl::Halo >::value_type vector_Sl_cosmobl_Halo_Sg__pop(vector< cosmobl::Halo > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *vector_Sl_cosmobl_Halo_Sg____getslice__(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::difference_type i,vector< cosmobl::Halo >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }

  namespace swig {
    template <>  struct traits<cosmobl::Halo > {
      typedef pointer_category category;
      static const char* type_name() { return"cosmobl::Halo"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector<cosmobl::Halo, std::allocator< cosmobl::Halo > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "cosmobl::Halo" "," "std::allocator< cosmobl::Halo >" " >";
	  }
	};
      }
    
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg____setslice____SWIG_0(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::difference_type i,vector< cosmobl::Halo >::difference_type j,std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &v=std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > >()){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg____delslice__(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::difference_type i,vector< cosmobl::Halo >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg____delitem____SWIG_0(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::difference_type i){
      self->erase(swig::getpos(self,i));
    }
SWIGINTERN std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *vector_Sl_cosmobl_Halo_Sg____getitem____SWIG_0(vector< cosmobl::Halo > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::difference_type id = i;
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg____setitem____SWIG_0(vector< cosmobl::Halo > *self,PySliceObject *slice,std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::difference_type id = i;
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg____setitem____SWIG_1(vector< cosmobl::Halo > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::difference_type id = i;
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg____delitem____SWIG_1(vector< cosmobl::Halo > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::difference_type id = i;
      std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN vector< cosmobl::Halo >::value_type const &vector_Sl_cosmobl_Halo_Sg____getitem____SWIG_1(vector< cosmobl::Halo > const *self,vector< cosmobl::Halo >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg____setitem____SWIG_2(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::difference_type i,vector< cosmobl::Halo >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg__append(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN vector< cosmobl::Halo >::iterator vector_Sl_cosmobl_Halo_Sg__erase__SWIG_0(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::iterator pos){ return self->erase(pos); }
SWIGINTERN vector< cosmobl::Halo >::iterator vector_Sl_cosmobl_Halo_Sg__erase__SWIG_1(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::iterator first,vector< cosmobl::Halo >::iterator last){ return self->erase(first, last); }
SWIGINTERN vector< cosmobl::Halo >::iterator vector_Sl_cosmobl_Halo_Sg__insert__SWIG_0(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::iterator pos,vector< cosmobl::Halo >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void vector_Sl_cosmobl_Halo_Sg__insert__SWIG_1(vector< cosmobl::Halo > *self,vector< cosmobl::Halo >::iterator pos,vector< cosmobl::Halo >::size_type n,vector< cosmobl::Halo >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN swig::SwigPyIterator *vector_Sl_cosmobl_Galaxy_Sg__iterator(vector< cosmobl::Galaxy > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool vector_Sl_cosmobl_Galaxy_Sg____nonzero__(vector< cosmobl::Galaxy > const *self){
      return !(self->empty());
    }
SWIGINTERN bool vector_Sl_cosmobl_Galaxy_Sg____bool__(vector< cosmobl::Galaxy > const *self){
      return !(self->empty());
    }
SWIGINTERN vector< cosmobl::Galaxy >::size_type vector_Sl_cosmobl_Galaxy_Sg____len__(vector< cosmobl::Galaxy > const *self){
      return self->size();
    }
SWIGINTERN vector< cosmobl::Galaxy >::value_type vector_Sl_cosmobl_Galaxy_Sg__pop(vector< cosmobl::Galaxy > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *vector_Sl_cosmobl_Galaxy_Sg____getslice__(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::difference_type i,vector< cosmobl::Galaxy >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }

  namespace swig {
    template <>  struct traits<cosmobl::Galaxy > {
      typedef pointer_category category;
      static const char* type_name() { return"cosmobl::Galaxy"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector<cosmobl::Galaxy, std::allocator< cosmobl::Galaxy > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "cosmobl::Galaxy" "," "std::allocator< cosmobl::Galaxy >" " >";
	  }
	};
      }
    
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg____setslice____SWIG_0(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::difference_type i,vector< cosmobl::Galaxy >::difference_type j,std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &v=std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >()){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg____delslice__(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::difference_type i,vector< cosmobl::Galaxy >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg____delitem____SWIG_0(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::difference_type i){
      self->erase(swig::getpos(self,i));
    }
SWIGINTERN std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *vector_Sl_cosmobl_Galaxy_Sg____getitem____SWIG_0(vector< cosmobl::Galaxy > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::difference_type id = i;
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg____setitem____SWIG_0(vector< cosmobl::Galaxy > *self,PySliceObject *slice,std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::difference_type id = i;
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg____setitem____SWIG_1(vector< cosmobl::Galaxy > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::difference_type id = i;
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg____delitem____SWIG_1(vector< cosmobl::Galaxy > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::difference_type id = i;
      std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN vector< cosmobl::Galaxy >::value_type const &vector_Sl_cosmobl_Galaxy_Sg____getitem____SWIG_1(vector< cosmobl::Galaxy > const *self,vector< cosmobl::Galaxy >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg____setitem____SWIG_2(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::difference_type i,vector< cosmobl::Galaxy >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg__append(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN vector< cosmobl::Galaxy >::iterator vector_Sl_cosmobl_Galaxy_Sg__erase__SWIG_0(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::iterator pos){ return self->erase(pos); }
SWIGINTERN vector< cosmobl::Galaxy >::iterator vector_Sl_cosmobl_Galaxy_Sg__erase__SWIG_1(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::iterator first,vector< cosmobl::Galaxy >::iterator last){ return self->erase(first, last); }
SWIGINTERN vector< cosmobl::Galaxy >::iterator vector_Sl_cosmobl_Galaxy_Sg__insert__SWIG_0(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::iterator pos,vector< cosmobl::Galaxy >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void vector_Sl_cosmobl_Galaxy_Sg__insert__SWIG_1(vector< cosmobl::Galaxy > *self,vector< cosmobl::Galaxy >::iterator pos,vector< cosmobl::Galaxy >::size_type n,vector< cosmobl::Galaxy >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN swig::SwigPyIterator *vector_Sl_cosmobl_Cluster_Sg__iterator(vector< cosmobl::Cluster > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool vector_Sl_cosmobl_Cluster_Sg____nonzero__(vector< cosmobl::Cluster > const *self){
      return !(self->empty());
    }
SWIGINTERN bool vector_Sl_cosmobl_Cluster_Sg____bool__(vector< cosmobl::Cluster > const *self){
      return !(self->empty());
    }
SWIGINTERN vector< cosmobl::Cluster >::size_type vector_Sl_cosmobl_Cluster_Sg____len__(vector< cosmobl::Cluster > const *self){
      return self->size();
    }
SWIGINTERN vector< cosmobl::Cluster >::value_type vector_Sl_cosmobl_Cluster_Sg__pop(vector< cosmobl::Cluster > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *vector_Sl_cosmobl_Cluster_Sg____getslice__(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::difference_type i,vector< cosmobl::Cluster >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }

  namespace swig {
    template <>  struct traits<cosmobl::Cluster > {
      typedef pointer_category category;
      static const char* type_name() { return"cosmobl::Cluster"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector<cosmobl::Cluster, std::allocator< cosmobl::Cluster > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "cosmobl::Cluster" "," "std::allocator< cosmobl::Cluster >" " >";
	  }
	};
      }
    
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg____setslice____SWIG_0(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::difference_type i,vector< cosmobl::Cluster >::difference_type j,std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &v=std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > >()){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg____delslice__(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::difference_type i,vector< cosmobl::Cluster >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg____delitem____SWIG_0(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::difference_type i){
      self->erase(swig::getpos(self,i));
    }
SWIGINTERN std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *vector_Sl_cosmobl_Cluster_Sg____getitem____SWIG_0(vector< cosmobl::Cluster > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::difference_type id = i;
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg____setitem____SWIG_0(vector< cosmobl::Cluster > *self,PySliceObject *slice,std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::difference_type id = i;
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg____setitem____SWIG_1(vector< cosmobl::Cluster > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::difference_type id = i;
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg____delitem____SWIG_1(vector< cosmobl::Cluster > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::difference_type id = i;
      std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN vector< cosmobl::Cluster >::value_type const &vector_Sl_cosmobl_Cluster_Sg____getitem____SWIG_1(vector< cosmobl::Cluster > const *self,vector< cosmobl::Cluster >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg____setitem____SWIG_2(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::difference_type i,vector< cosmobl::Cluster >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg__append(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN vector< cosmobl::Cluster >::iterator vector_Sl_cosmobl_Cluster_Sg__erase__SWIG_0(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::iterator pos){ return self->erase(pos); }
SWIGINTERN vector< cosmobl::Cluster >::iterator vector_Sl_cosmobl_Cluster_Sg__erase__SWIG_1(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::iterator first,vector< cosmobl::Cluster >::iterator last){ return self->erase(first, last); }
SWIGINTERN vector< cosmobl::Cluster >::iterator vector_Sl_cosmobl_Cluster_Sg__insert__SWIG_0(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::iterator pos,vector< cosmobl::Cluster >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void vector_Sl_cosmobl_Cluster_Sg__insert__SWIG_1(vector< cosmobl::Cluster > *self,vector< cosmobl::Cluster >::iterator pos,vector< cosmobl::Cluster >::size_type n,vector< cosmobl::Cluster >::value_type const &x){ self->insert(pos, n, x); }

#include "LogNormal.h"


#include "RandomCatalogue.h"


#include "Pairs.h"
#include "TwoPointCorrelation.h"


#include "ModelTwoPointCorrelation.h"


#include "Triplets.h"
#include "ThreePointCorrelation.h"


#include "GlobalFunc.h"

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (swig::SwigPyIterator *)(arg1)->incr();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SwigPyIterator_incr__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator_incr__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::incr(size_t)\n"
    "    swig::SwigPyIterator::incr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (swig::SwigPyIterator *)(arg1)->decr();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::decr(size_t)\n"
    "    swig::SwigPyIterator::decr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  ptrdiff_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  try {
    result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
  }
  catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
  }
  
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  try {
    result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
  }
  catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->next();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->__next__();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->previous();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  ptrdiff_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SHARED_PTR_DISOWN_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "SHARED_PTR_DISOWN",SWIG_From_int(static_cast< int >(0)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_wrap_WarningMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:WarningMsg",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "WarningMsg" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  cosmobl::WarningMsg(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ErrorMsg",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ErrorMsg" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  cosmobl::ErrorMsg(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Beep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!PyArg_ParseTuple(args,(char *)":Beep")) SWIG_fail;
  cosmobl::Beep();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!PyArg_ParseTuple(args,(char *)":Exit")) SWIG_fail;
  cosmobl::Exit();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_isSet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:isSet",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "isSet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (bool)cosmobl::isSet(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_isSet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:isSet",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isSet" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isSet" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (bool)cosmobl::isSet(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_isSet(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_isSet__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_isSet__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'isSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::isSet(double const)\n"
    "    cosmobl::isSet(std::vector< double > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShortSwap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  short arg1 ;
  short val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  short result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ShortSwap",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_short(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ShortSwap" "', argument " "1"" of type '" "short""'");
  } 
  arg1 = static_cast< short >(val1);
  result = (short)cosmobl::ShortSwap(arg1);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntSwap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:IntSwap",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IntSwap" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (int)cosmobl::IntSwap(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LongSwap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  long arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LongSwap",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LongSwap" "', argument " "1"" of type '" "long""'");
  } 
  arg1 = static_cast< long >(val1);
  result = (long)cosmobl::LongSwap(arg1);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LongLongSwap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  long long arg1 ;
  long long val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  long long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LongLongSwap",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LongLongSwap" "', argument " "1"" of type '" "long long""'");
  } 
  arg1 = static_cast< long long >(val1);
  result = (long long)cosmobl::LongLongSwap(arg1);
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatSwap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  float result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FloatSwap",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FloatSwap" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  result = (float)cosmobl::FloatSwap(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleSwap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DoubleSwap",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DoubleSwap" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (double)cosmobl::DoubleSwap(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_interpolated__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::string arg4 ;
  int arg5 ;
  double *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:interpolated",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "interpolated" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "interpolated" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "interpolated" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "interpolated" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "interpolated" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "interpolated" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "interpolated" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "interpolated" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "interpolated" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  result = (double)cosmobl::interpolated(arg1,arg2,arg3,arg4,arg5,*arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_interpolated__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::string arg4 ;
  int arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:interpolated",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "interpolated" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "interpolated" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "interpolated" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "interpolated" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "interpolated" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "interpolated" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "interpolated" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)cosmobl::interpolated(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_interpolated(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_interpolated__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_interpolated__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'interpolated'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::interpolated(double const,std::vector< double > const,std::vector< double > const,std::string const,int const,double &)\n"
    "    cosmobl::interpolated(double const,std::vector< double > const,std::vector< double > const,std::string const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_interpolated_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg5 ;
  std::string arg6 ;
  int arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:interpolated_2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "interpolated_2D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "interpolated_2D" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "interpolated_2D" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "interpolated_2D" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "interpolated_2D" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "interpolated_2D" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "interpolated_2D" "', argument " "5"" of type '" "std::vector< std::vector< double > > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "interpolated_2D" "', argument " "5"" of type '" "std::vector< std::vector< double > > const""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "interpolated_2D" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "interpolated_2D" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)cosmobl::interpolated_2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_checkIO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:checkIO",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "checkIO" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "checkIO" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  cosmobl::checkIO(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_convert_map_gnuplot_sm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:convert_map_gnuplot_sm",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "convert_map_gnuplot_sm" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "convert_map_gnuplot_sm" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  cosmobl::convert_map_gnuplot_sm(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_EnvVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::string > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:set_EnvVar",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_EnvVar" "', argument " "1"" of type '" "std::vector< std::string > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_EnvVar" "', argument " "1"" of type '" "std::vector< std::string > const""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  cosmobl::set_EnvVar(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_EnvVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:check_EnvVar",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "check_EnvVar" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  cosmobl::check_EnvVar(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_used_memory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:used_memory",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "used_memory" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (int)cosmobl::used_memory(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_memory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  bool arg2 ;
  std::string arg3 ;
  int arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:check_memory",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "check_memory" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "check_memory" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "check_memory" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "check_memory" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)cosmobl::check_memory(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_memory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  bool arg2 ;
  std::string arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:check_memory",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "check_memory" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "check_memory" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "check_memory" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)cosmobl::check_memory(arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_memory__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  bool arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:check_memory",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "check_memory" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "check_memory" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)cosmobl::check_memory(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_memory__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:check_memory",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "check_memory" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (int)cosmobl::check_memory(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_memory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_check_memory__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_check_memory__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_check_memory__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_check_memory__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'check_memory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::check_memory(double const,bool const,std::string const,int const)\n"
    "    cosmobl::check_memory(double const,bool const,std::string const)\n"
    "    cosmobl::check_memory(double const,bool const)\n"
    "    cosmobl::check_memory(double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_random_numbers__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  std::vector< double > *arg5 = 0 ;
  double arg6 ;
  double arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:random_numbers",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_numbers" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_numbers" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "random_numbers" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "random_numbers" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "random_numbers" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "random_numbers" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "random_numbers" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  cosmobl::random_numbers(arg1,arg2,arg3,arg4,*arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_numbers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  std::vector< double > *arg5 = 0 ;
  double arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:random_numbers",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_numbers" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_numbers" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "random_numbers" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "random_numbers" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "random_numbers" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "random_numbers" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  cosmobl::random_numbers(arg1,arg2,arg3,arg4,*arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_numbers__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  std::vector< double > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:random_numbers",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_numbers" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_numbers" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "random_numbers" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "random_numbers" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "random_numbers" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_numbers" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  cosmobl::random_numbers(arg1,arg2,arg3,arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_numbers(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_random_numbers__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_random_numbers__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_random_numbers__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'random_numbers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::random_numbers(int const,int const,std::vector< double > const,std::vector< double > const,std::vector< double > &,double const,double const)\n"
    "    cosmobl::random_numbers(int const,int const,std::vector< double > const,std::vector< double > const,std::vector< double > &,double const)\n"
    "    cosmobl::random_numbers(int const,int const,std::vector< double > const,std::vector< double > const,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fullpath__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:fullpath",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fullpath" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fullpath" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = cosmobl::fullpath(arg1,arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fullpath__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:fullpath",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fullpath" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = cosmobl::fullpath(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fullpath(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_fullpath__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_fullpath__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'fullpath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::fullpath(std::string const,bool const)\n"
    "    cosmobl::fullpath(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_gauleg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ;
  int arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:gauleg",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gauleg" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gauleg" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gauleg" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gauleg" "', argument " "4"" of type '" "double *""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gauleg" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  cosmobl::gauleg(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unique_unsorted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:unique_unsorted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unique_unsorted" "', argument " "1"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "unique_unsorted" "', argument " "1"" of type '" "std::vector< int > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  cosmobl::unique_unsorted(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unique_unsorted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:unique_unsorted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unique_unsorted" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "unique_unsorted" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  cosmobl::unique_unsorted(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unique_unsorted__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:unique_unsorted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unique_unsorted" "', argument " "1"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "unique_unsorted" "', argument " "1"" of type '" "std::vector< std::string > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  cosmobl::unique_unsorted(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unique_unsorted(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_unique_unsorted__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_unique_unsorted__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_unique_unsorted__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'unique_unsorted'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::unique_unsorted(std::vector< int > &)\n"
    "    cosmobl::unique_unsorted(std::vector< double > &)\n"
    "    cosmobl::unique_unsorted(std::vector< std::string > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CL_VV_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::CL *arg1 = (cosmobl::glob::CL *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CL_VV_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__CL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CL_VV_set" "', argument " "1"" of type '" "cosmobl::glob::CL *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::CL * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CL_VV_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->VV = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CL_VV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::CL *arg1 = (cosmobl::glob::CL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CL_VV_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__CL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CL_VV_get" "', argument " "1"" of type '" "cosmobl::glob::CL *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::CL * >(argp1);
  result = (std::vector< double > *)& ((arg1)->VV);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::glob::CL *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CL",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CL" "', argument " "1"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CL" "', argument " "1"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::glob::CL *)new cosmobl::glob::CL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__CL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::CL *arg1 = (cosmobl::glob::CL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__CL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CL" "', argument " "1"" of type '" "cosmobl::glob::CL *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::CL * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__CL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::CL *arg1 = 0 ;
  cosmobl::glob::CL *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cosmobl__glob__CL,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "cosmobl::glob::CL const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "cosmobl::glob::CL const &""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::CL * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__glob__CL,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "cosmobl::glob::CL const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "cosmobl::glob::CL const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::glob::CL * >(argp2);
  result = (bool)cosmobl::glob::operator <((cosmobl::glob::CL const &)*arg1,(cosmobl::glob::CL const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sort_2vectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg1 ;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:sort_2vectors",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort_2vectors" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_2vectors" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort_2vectors" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_2vectors" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sort_2vectors" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  cosmobl::sort_2vectors(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sort_3vectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg1 ;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg2 ;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg3 ;
  int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:sort_3vectors",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort_3vectors" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_3vectors" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort_3vectors" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_3vectors" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort_3vectors" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_3vectors" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sort_3vectors" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  cosmobl::sort_3vectors(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sort_4vectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg1 ;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg2 ;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg3 ;
  SwigValueWrapper< std::vector< double,std::allocator< double > >::iterator > arg4 ;
  int arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:sort_4vectors",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort_4vectors" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_4vectors" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort_4vectors" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_4vectors" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort_4vectors" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_4vectors" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sort_4vectors" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > >::iterator""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort_4vectors" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > >::iterator""'");
    } else {
      std::vector< double,std::allocator< double > >::iterator * temp = reinterpret_cast< std::vector< double,std::allocator< double > >::iterator * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "sort_4vectors" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  cosmobl::sort_4vectors(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > > > *arg1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__mul__" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__mul__" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  result = cosmobl::operator *((std::vector< std::vector< double,std::allocator< double > > > const &)*arg1,(std::vector< std::vector< double,std::allocator< double > > > const &)*arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double,std::allocator< double > > >(static_cast< const std::vector< std::vector< double,std::allocator< double > > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MatDoub *arg1 = 0 ;
  MatDoub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  MatDoub result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_MatDoub,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__mul__" "', argument " "1"" of type '" "MatDoub const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "1"" of type '" "MatDoub const &""'"); 
  }
  arg1 = reinterpret_cast< MatDoub * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_MatDoub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__mul__" "', argument " "2"" of type '" "MatDoub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "2"" of type '" "MatDoub const &""'"); 
  }
  arg2 = reinterpret_cast< MatDoub * >(argp2);
  result = cosmobl::operator *((MatDoub const &)*arg1,(MatDoub const &)*arg2);
  resultobj = SWIG_NewPointerObj((new MatDoub(static_cast< const MatDoub& >(result))), SWIGTYPE_p_MatDoub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___mul__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_MatDoub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MatDoub, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_invert_matrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  double arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:invert_matrix",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "invert_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "invert_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "invert_matrix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  cosmobl::invert_matrix(arg1,*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_invert_matrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:invert_matrix",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "invert_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "invert_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  cosmobl::invert_matrix(arg1,*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_invert_matrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:invert_matrix",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "invert_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "invert_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "invert_matrix" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "invert_matrix" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "invert_matrix" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  cosmobl::invert_matrix(arg1,*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_invert_matrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:invert_matrix",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "invert_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "invert_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "invert_matrix" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "invert_matrix" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  cosmobl::invert_matrix(arg1,*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_invert_matrix(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_invert_matrix__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_invert_matrix__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_invert_matrix__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_invert_matrix__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'invert_matrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::invert_matrix(std::vector< std::vector< double,std::allocator< double > > > const,std::vector< std::vector< double,std::allocator< double > > > &,double const)\n"
    "    cosmobl::invert_matrix(std::vector< std::vector< double,std::allocator< double > > > const,std::vector< std::vector< double,std::allocator< double > > > &)\n"
    "    cosmobl::invert_matrix(std::vector< std::vector< double,std::allocator< double > > > const,std::vector< std::vector< double,std::allocator< double > > > &,int const,int const,double const)\n"
    "    cosmobl::invert_matrix(std::vector< std::vector< double,std::allocator< double > > > const,std::vector< std::vector< double,std::allocator< double > > > &,int const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_invert_small_matrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  double arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:invert_small_matrix",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "invert_small_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_small_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "invert_small_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_small_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "invert_small_matrix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  cosmobl::invert_small_matrix(arg1,*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_invert_small_matrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:invert_small_matrix",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "invert_small_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_small_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "invert_small_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert_small_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  cosmobl::invert_small_matrix(arg1,*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_invert_small_matrix(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_invert_small_matrix__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_invert_small_matrix__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'invert_small_matrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::invert_small_matrix(std::vector< std::vector< double,std::allocator< double > > > const,std::vector< std::vector< double,std::allocator< double > > > &,double const)\n"
    "    cosmobl::invert_small_matrix(std::vector< std::vector< double,std::allocator< double > > > const,std::vector< std::vector< double,std::allocator< double > > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_covariance_matrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:covariance_matrix",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "covariance_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "covariance_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "covariance_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "covariance_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "covariance_matrix" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  cosmobl::covariance_matrix(arg1,*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_covariance_matrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:covariance_matrix",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "covariance_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "covariance_matrix" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "covariance_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "covariance_matrix" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  cosmobl::covariance_matrix(arg1,*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_covariance_matrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::string > > arg1 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:covariance_matrix",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "covariance_matrix" "', argument " "1"" of type '" "std::vector< std::string > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "covariance_matrix" "', argument " "1"" of type '" "std::vector< std::string > const""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "covariance_matrix" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "covariance_matrix" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "covariance_matrix" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "covariance_matrix" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "covariance_matrix" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "covariance_matrix" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
  cosmobl::covariance_matrix(arg1,*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_covariance_matrix(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_covariance_matrix__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_covariance_matrix__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_covariance_matrix__SWIG_2(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'covariance_matrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::covariance_matrix(std::vector< std::vector< double,std::allocator< double > > > const,std::vector< std::vector< double,std::allocator< double > > > &,bool const)\n"
    "    cosmobl::covariance_matrix(std::vector< std::vector< double,std::allocator< double > > > const,std::vector< std::vector< double,std::allocator< double > > > &)\n"
    "    cosmobl::covariance_matrix(std::vector< std::string > const,std::vector< double > &,std::vector< double > &,std::vector< std::vector< double,std::allocator< double > > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_read_cov(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:read_cov",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "read_cov" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "read_cov" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "read_cov" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "read_cov" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "read_cov" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "read_cov" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "read_cov" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  cosmobl::read_cov(arg1,*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fill_distr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  double arg5 ;
  std::vector< double > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:fill_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fill_distr" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fill_distr" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fill_distr" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fill_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fill_distr" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "fill_distr" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  cosmobl::fill_distr(arg1,arg2,arg3,*arg4,arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fill_distr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  int arg3 ;
  std::vector< double > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:fill_distr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fill_distr" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fill_distr" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fill_distr" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fill_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  cosmobl::fill_distr(arg1,arg2,arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fill_distr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:fill_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fill_distr" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fill_distr" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fill_distr" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fill_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fill_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fill_distr" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fill_distr" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fill_distr" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  cosmobl::fill_distr(arg1,arg2,arg3,*arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fill_distr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_fill_distr__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_fill_distr__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_fill_distr__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'fill_distr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::fill_distr(std::vector< double > const,double const,std::vector< double > const,std::vector< double > &,double const,std::vector< double > &)\n"
    "    cosmobl::fill_distr(std::vector< double > const,std::vector< double > const,int const,std::vector< double > &)\n"
    "    cosmobl::fill_distr(int const,std::vector< double > const,std::vector< double > const,std::vector< double > &,double const,double const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_find_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  double arg2 ;
  double arg3 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:find_index",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "find_index" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "find_index" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "find_index" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "find_index" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "find_index" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "find_index" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "find_index" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "find_index" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  cosmobl::find_index(arg1,arg2,arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Moment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Moment",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Moment" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Moment" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Moment" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Moment" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Moment" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Moment" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Moment" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Moment" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Moment" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Moment" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Moment" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Moment" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Moment" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Moment" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  cosmobl::Moment(arg1,*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_linearfit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Doub arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  VecDoub result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:linearfit",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Doub,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "linearfit" "', argument " "1"" of type '" "Doub const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "linearfit" "', argument " "1"" of type '" "Doub const""'");
    } else {
      Doub * temp = reinterpret_cast< Doub * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = cosmobl::linearfit(arg1);
  resultobj = SWIG_NewPointerObj((new VecDoub(static_cast< const VecDoub& >(result))), SWIGTYPE_p_VecDoub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quadratic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Doub arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  VecDoub result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:quadratic",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Doub,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quadratic" "', argument " "1"" of type '" "Doub const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "quadratic" "', argument " "1"" of type '" "Doub const""'");
    } else {
      Doub * temp = reinterpret_cast< Doub * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = cosmobl::quadratic(arg1);
  resultobj = SWIG_NewPointerObj((new VecDoub(static_cast< const VecDoub& >(result))), SWIGTYPE_p_VecDoub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cubicfit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Doub arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  VecDoub result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:cubicfit",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Doub,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cubicfit" "', argument " "1"" of type '" "Doub const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cubicfit" "', argument " "1"" of type '" "Doub const""'");
    } else {
      Doub * temp = reinterpret_cast< Doub * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = cosmobl::cubicfit(arg1);
  resultobj = SWIG_NewPointerObj((new VecDoub(static_cast< const VecDoub& >(result))), SWIGTYPE_p_VecDoub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_measure_var_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  std::vector< double > *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:measure_var_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "measure_var_function" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "measure_var_function" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "measure_var_function" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "measure_var_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "measure_var_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "measure_var_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "measure_var_function" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "measure_var_function" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "measure_var_function" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "measure_var_function" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "measure_var_function" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "measure_var_function" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  arg8 = reinterpret_cast< std::vector< double > * >(argp8);
  cosmobl::measure_var_function(arg1,arg2,arg3,arg4,arg5,*arg6,*arg7,*arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_quad_fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:quad_fit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quad_fit" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "quad_fit" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quad_fit" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "quad_fit" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "quad_fit" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "quad_fit" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "quad_fit" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "quad_fit" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "quad_fit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "quad_fit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "quad_fit" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "quad_fit" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  cosmobl::quad_fit(arg1,arg2,arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gaussian_fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:gaussian_fit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gaussian_fit" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gaussian_fit" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gaussian_fit" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gaussian_fit" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gaussian_fit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gaussian_fit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gaussian_fit" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gaussian_fit" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  cosmobl::gaussian_fit(arg1,arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gaussian_convolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:gaussian_convolution",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gaussian_convolution" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gaussian_convolution" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gaussian_convolution" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gaussian_convolution" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gaussian_convolution" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gaussian_convolution" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::gaussian_convolution(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "distribution" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "distribution" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "distribution" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "distribution" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "distribution" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "distribution" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  bool arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "distribution" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "distribution" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "distribution" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "distribution" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "distribution" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "distribution" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "distribution" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "distribution" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "distribution" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "distribution" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "distribution" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "distribution" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "distribution" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "distribution" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "distribution" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "distribution" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "distribution" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "distribution" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "distribution" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:distribution",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "distribution" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  cosmobl::distribution(*arg1,*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_distribution(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[14] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 13) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_distribution__SWIG_8(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_distribution__SWIG_7(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_distribution__SWIG_6(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_distribution__SWIG_5(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_distribution__SWIG_4(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_distribution__SWIG_3(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_distribution__SWIG_2(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_distribution__SWIG_1(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_distribution__SWIG_0(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'distribution'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const,bool const,std::string const,double const,double const,double const,bool const,bool const,double const)\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const,bool const,std::string const,double const,double const,double const,bool const,bool const)\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const,bool const,std::string const,double const,double const,double const,bool const)\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const,bool const,std::string const,double const,double const,double const)\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const,bool const,std::string const,double const,double const)\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const,bool const,std::string const,double const)\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const,bool const,std::string const)\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const,bool const)\n"
    "    cosmobl::distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MC_Int__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(double const) = (double (*)(double const)) 0 ;
  double arg2 ;
  double arg3 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MC_Int",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_q_const__double__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "MC_Int" "', argument " "1"" of type '" "double (*)(double const)""'"); 
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MC_Int" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MC_Int" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)cosmobl::MC_Int(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MC_Int__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(double const,double const) = (double (*)(double const,double const)) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MC_Int",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_q_const__double_q_const__double__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "MC_Int" "', argument " "1"" of type '" "double (*)(double const,double const)""'"); 
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MC_Int" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MC_Int" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MC_Int" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::MC_Int(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MC_Int__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double (*arg1)(double const,double const,double const,double const,double const,double const) = (double (*)(double const,double const,double const,double const,double const,double const)) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:MC_Int",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "MC_Int" "', argument " "1"" of type '" "double (*)(double const,double const,double const,double const,double const,double const)""'"); 
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MC_Int" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MC_Int" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MC_Int" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MC_Int" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MC_Int" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MC_Int" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "MC_Int" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)cosmobl::MC_Int(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MC_Int(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *ptr = 0;
    int res = SWIG_ConvertFunctionPtr(argv[0], &ptr, SWIGTYPE_p_f_q_const__double__double);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MC_Int__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *ptr = 0;
    int res = SWIG_ConvertFunctionPtr(argv[0], &ptr, SWIGTYPE_p_f_q_const__double_q_const__double__double);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MC_Int__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *ptr = 0;
    int res = SWIG_ConvertFunctionPtr(argv[0], &ptr, SWIGTYPE_p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_MC_Int__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MC_Int'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::MC_Int(double (*)(double const),double const,double const)\n"
    "    cosmobl::MC_Int(double (*)(double const,double const),double const,double const,double)\n"
    "    cosmobl::MC_Int(double (*)(double const,double const,double const,double const,double const,double const),double const,double const,double const,double const,double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_D1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:D1",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "D1" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D1" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D1" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "D1" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D1" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "D1" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "D1" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "D1" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::D1(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:D2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "D2" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D2" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D2" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "D2" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D2" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "D2" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "D2" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "D2" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::D2(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Deriv__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Deriv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Deriv" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Deriv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Deriv" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Deriv" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Deriv" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Deriv" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Deriv" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Deriv" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Deriv" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)cosmobl::Deriv(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Deriv__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  std::string arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Deriv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Deriv" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Deriv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Deriv" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Deriv" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Deriv" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Deriv" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Deriv" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Deriv" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)cosmobl::Deriv(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Deriv__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  std::string arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Deriv",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Deriv" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Deriv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Deriv" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Deriv" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Deriv" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Deriv" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Deriv" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)cosmobl::Deriv(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Deriv(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Deriv__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Deriv__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Deriv__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Deriv'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Deriv(int const,double const,std::vector< double > const,std::vector< double > const,std::string const,int const,double const)\n"
    "    cosmobl::Deriv(int const,double const,std::vector< double > const,std::vector< double > const,std::string const,int const)\n"
    "    cosmobl::Deriv(int const,double const,std::vector< double > const,std::vector< double > const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bin_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double (*arg2)(double,void *) = (double (*)(double,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::vector< double > *arg8 = 0 ;
  std::vector< double > *arg9 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:bin_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "bin_function" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "bin_function" "', argument " "2"" of type '" "double (*)(double,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bin_function" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "bin_function" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "bin_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "bin_function" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "bin_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "bin_function" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bin_function" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  arg8 = reinterpret_cast< std::vector< double > * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "bin_function" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bin_function" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  arg9 = reinterpret_cast< std::vector< double > * >(argp9);
  cosmobl::bin_function(arg1,arg2,arg3,arg4,arg5,arg6,arg7,*arg8,*arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bin_function_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double (*arg2)(double *,size_t,void *) = (double (*)(double *,size_t,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  std::string arg9 ;
  std::vector< double > *arg10 = 0 ;
  std::vector< double > *arg11 = 0 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg12 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:bin_function_2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "bin_function_2D" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_double_size_t_p_void__double);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "bin_function_2D" "', argument " "2"" of type '" "double (*)(double *,size_t,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bin_function_2D" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "bin_function_2D" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "bin_function_2D" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "bin_function_2D" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "bin_function_2D" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "bin_function_2D" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "bin_function_2D" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "bin_function_2D" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bin_function_2D" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "bin_function_2D" "', argument " "11"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bin_function_2D" "', argument " "11"" of type '" "std::vector< double > &""'"); 
  }
  arg11 = reinterpret_cast< std::vector< double > * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "bin_function_2D" "', argument " "12"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bin_function_2D" "', argument " "12"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp12);
  cosmobl::bin_function_2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,*arg10,*arg11,*arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_grid_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_grid_lin",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "func_grid_lin" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "func_grid_lin" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::func_grid_lin(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_grid_loglin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_grid_loglin",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "func_grid_loglin" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "func_grid_loglin" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::func_grid_loglin(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_grid_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_grid_log",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "func_grid_log" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "func_grid_log" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::func_grid_log(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_grid_lin_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:func_grid_lin_2D",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "func_grid_lin_2D" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "func_grid_lin_2D" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "func_grid_lin_2D" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::func_grid_lin_2D(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_grid_loglin_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:func_grid_loglin_2D",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "func_grid_loglin_2D" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "func_grid_loglin_2D" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "func_grid_loglin_2D" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::func_grid_loglin_2D(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_grid_log_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:func_grid_log_2D",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "func_grid_log_2D" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "func_grid_log_2D" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "func_grid_log_2D" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::func_grid_log_2D(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_convolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::vector< double > *arg3 = 0 ;
  double arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:convolution",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "convolution" "', argument " "1"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "convolution" "', argument " "1"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "convolution" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "convolution" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "convolution" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "convolution" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "convolution" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  cosmobl::convolution(arg1,arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_polar_coord__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:polar_coord",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "polar_coord" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "polar_coord" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "polar_coord" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "polar_coord" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "polar_coord" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "polar_coord" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  cosmobl::polar_coord(arg1,arg2,arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cartesian_coord__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cartesian_coord",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cartesian_coord" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cartesian_coord" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cartesian_coord" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cartesian_coord" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cartesian_coord" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cartesian_coord" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  cosmobl::cartesian_coord(arg1,arg2,arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_polar_coord__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:polar_coord",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "polar_coord" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "polar_coord" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "polar_coord" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "polar_coord" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "polar_coord" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "polar_coord" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polar_coord" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  cosmobl::polar_coord(arg1,arg2,arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_polar_coord(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_polar_coord__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_polar_coord__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'polar_coord'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::polar_coord(double const,double const,double const,double &,double &,double &)\n"
    "    cosmobl::polar_coord(std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > &,std::vector< double > &,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_cartesian_coord__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cartesian_coord",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cartesian_coord" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cartesian_coord" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cartesian_coord" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cartesian_coord" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cartesian_coord" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cartesian_coord" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cartesian_coord" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  cosmobl::cartesian_coord(arg1,arg2,arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cartesian_coord(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_cartesian_coord__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_cartesian_coord__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'cartesian_coord'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::cartesian_coord(double const,double const,double const,double &,double &,double &)\n"
    "    cosmobl::cartesian_coord(std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > &,std::vector< double > &,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_eq2sdss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:eq2sdss",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eq2sdss" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eq2sdss" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eq2sdss" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eq2sdss" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "eq2sdss" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eq2sdss" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "eq2sdss" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eq2sdss" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  cosmobl::eq2sdss(arg1,arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sdss2eq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:sdss2eq",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sdss2eq" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sdss2eq" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sdss2eq" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sdss2eq" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sdss2eq" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sdss2eq" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sdss2eq" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sdss2eq" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  cosmobl::sdss2eq(arg1,arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sdss_stripe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::vector< int > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:sdss_stripe",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sdss_stripe" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sdss_stripe" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sdss_stripe" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sdss_stripe" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sdss_stripe" "', argument " "3"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sdss_stripe" "', argument " "3"" of type '" "std::vector< int > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< int > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sdss_stripe" "', argument " "4"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sdss_stripe" "', argument " "4"" of type '" "std::vector< int > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< int > * >(argp4);
  cosmobl::sdss_stripe(arg1,arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xi_from_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xi_from_Pk" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "xi_from_Pk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xi_from_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xi_from_Pk" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xi_from_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:xi_from_Pk",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_from_Pk" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xi_from_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xi_from_Pk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "xi_from_Pk" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "xi_from_Pk" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xi_from_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xi_from_Pk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "xi_from_Pk" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xi_from_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xi_from_Pk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xi_from_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi_from_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:xi_from_Pk",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi_from_Pk" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:xi_from_Pk",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi_from_Pk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)cosmobl::xi_from_Pk(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:xi_from_Pk",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_from_Pk" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "xi_from_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)cosmobl::xi_from_Pk(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_from_Pk(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_xi_from_Pk__SWIG_13(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_xi_from_Pk__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_xi_from_Pk__SWIG_12(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_xi_from_Pk__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_xi_from_Pk__SWIG_11(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_xi_from_Pk__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_xi_from_Pk__SWIG_10(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_xi_from_Pk__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_xi_from_Pk__SWIG_9(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_xi_from_Pk__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_xi_from_Pk__SWIG_8(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_xi_from_Pk__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_xi_from_Pk__SWIG_7(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_xi_from_Pk__SWIG_6(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'xi_from_Pk'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::xi_from_Pk(double const,std::vector< double > const,std::vector< double > const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::xi_from_Pk(double const,std::vector< double > const,std::vector< double > const,double const,double const,double const,bool const)\n"
    "    cosmobl::xi_from_Pk(double const,std::vector< double > const,std::vector< double > const,double const,double const,double const)\n"
    "    cosmobl::xi_from_Pk(double const,std::vector< double > const,std::vector< double > const,double const,double const)\n"
    "    cosmobl::xi_from_Pk(double const,std::vector< double > const,std::vector< double > const,double const)\n"
    "    cosmobl::xi_from_Pk(double const,std::vector< double > const,std::vector< double > const)\n"
    "    cosmobl::xi_from_Pk(double const,std::string const,int const,int const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::xi_from_Pk(double const,std::string const,int const,int const,double const,double const,double const,bool const)\n"
    "    cosmobl::xi_from_Pk(double const,std::string const,int const,int const,double const,double const,double const)\n"
    "    cosmobl::xi_from_Pk(double const,std::string const,int const,int const,double const,double const)\n"
    "    cosmobl::xi_from_Pk(double const,std::string const,int const,int const,double const)\n"
    "    cosmobl::xi_from_Pk(double const,std::string const,int const,int const)\n"
    "    cosmobl::xi_from_Pk(double const,std::string const,int const)\n"
    "    cosmobl::xi_from_Pk(double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Pk_from_xi",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Pk_from_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pk_from_xi" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pk_from_xi" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pk_from_xi" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pk_from_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::Pk_from_xi(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pk_from_xi",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Pk_from_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pk_from_xi" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pk_from_xi" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pk_from_xi" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::Pk_from_xi(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pk_from_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Pk_from_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pk_from_xi" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pk_from_xi" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::Pk_from_xi(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Pk_from_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Pk_from_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pk_from_xi" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pk_from_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pk_from_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Pk_from_xi" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::Pk_from_xi(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Pk_from_xi",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Pk_from_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pk_from_xi" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pk_from_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pk_from_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::Pk_from_xi(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pk_from_xi",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Pk_from_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pk_from_xi" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pk_from_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)cosmobl::Pk_from_xi(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  int arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pk_from_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Pk_from_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pk_from_xi" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)cosmobl::Pk_from_xi(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pk_from_xi",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Pk_from_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pk_from_xi" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)cosmobl::Pk_from_xi(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pk_from_xi(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pk_from_xi__SWIG_7(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Pk_from_xi__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pk_from_xi__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Pk_from_xi__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Pk_from_xi__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Pk_from_xi__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Pk_from_xi__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Pk_from_xi__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pk_from_xi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pk_from_xi(double const,std::vector< double > const,std::vector< double > const,double const,double const)\n"
    "    cosmobl::Pk_from_xi(double const,std::vector< double > const,std::vector< double > const,double const)\n"
    "    cosmobl::Pk_from_xi(double const,std::vector< double > const,std::vector< double > const)\n"
    "    cosmobl::Pk_from_xi(double const,std::string const,int const,int const,double const,double const)\n"
    "    cosmobl::Pk_from_xi(double const,std::string const,int const,int const,double const)\n"
    "    cosmobl::Pk_from_xi(double const,std::string const,int const,int const)\n"
    "    cosmobl::Pk_from_xi(double const,std::string const,int const)\n"
    "    cosmobl::Pk_from_xi(double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_func_xi_GSL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_xi_GSL",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "func_xi_GSL" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "func_xi_GSL" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::glob::func_xi_GSL(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_SSM_GSL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_SSM_GSL",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "func_SSM_GSL" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "func_SSM_GSL" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::glob::func_SSM_GSL(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_wp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:wp",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wp" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wp" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wp" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wp" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wp" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "wp" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::wp(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_wp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:wp",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wp" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wp" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wp" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wp" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wp" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::wp(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_wp__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:wp",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wp" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "wp" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "wp" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)cosmobl::wp(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_wp__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:wp",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wp" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "wp" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)cosmobl::wp(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_wp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_wp__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_wp__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_wp__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_wp__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'wp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::wp(double const,std::vector< double > const,std::vector< double > const,double const)\n"
    "    cosmobl::wp(double const,std::vector< double > const,std::vector< double > const)\n"
    "    cosmobl::wp(double const,std::string const,double const)\n"
    "    cosmobl::wp(double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_sigmaR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:sigmaR",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sigmaR" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sigmaR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sigmaR" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sigmaR" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sigmaR" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sigmaR" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  result = (double)cosmobl::sigmaR(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_projected_powerlaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:xi_projected_powerlaw",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_projected_powerlaw" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi_projected_powerlaw" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi_projected_powerlaw" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)cosmobl::xi_projected_powerlaw(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_ratio__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:xi_ratio",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_ratio" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (double)cosmobl::xi_ratio(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_ratio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:xi_ratio",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_ratio" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi_ratio" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)cosmobl::xi_ratio(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_ratio__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::shared_ptr< void > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:xi_ratio",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi_ratio" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_void_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xi_ratio" "', argument " "2"" of type '" "std::shared_ptr< void >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_ratio" "', argument " "2"" of type '" "std::shared_ptr< void >""'");
    } else {
      std::shared_ptr< void > * temp = reinterpret_cast< std::shared_ptr< void > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi_ratio" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi_ratio" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::xi_ratio(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi_ratio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_xi_ratio__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_xi_ratio__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_void_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_xi_ratio__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'xi_ratio'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::xi_ratio(double const)\n"
    "    cosmobl::xi_ratio(double const,double const)\n"
    "    cosmobl::xi_ratio(double,std::shared_ptr< void >,std::vector< double >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_error_xi_ratio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:error_xi_ratio",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "error_xi_ratio" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "error_xi_ratio" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)cosmobl::error_xi_ratio(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi_direct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:barred_xi_direct",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi_direct" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi_direct" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_direct" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi_direct" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_direct" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi_direct" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "barred_xi_direct" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "barred_xi_direct" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::barred_xi_direct(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi_direct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:barred_xi_direct",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi_direct" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi_direct" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_direct" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi_direct" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_direct" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi_direct" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "barred_xi_direct" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::barred_xi_direct(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi_direct__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:barred_xi_direct",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi_direct" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi_direct" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_direct" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi_direct" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_direct" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi_direct" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::barred_xi_direct(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi_direct__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:barred_xi_direct",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi_direct" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi_direct" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_direct" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi_direct" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_direct" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::barred_xi_direct(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi_direct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_barred_xi_direct__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_barred_xi_direct__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_barred_xi_direct__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_barred_xi_direct__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'barred_xi_direct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::barred_xi_direct(double const,std::vector< double > const,std::vector< double > const,double const,double const,double const)\n"
    "    cosmobl::barred_xi_direct(double const,std::vector< double > const,std::vector< double > const,double const,double const)\n"
    "    cosmobl::barred_xi_direct(double const,std::vector< double > const,std::vector< double > const,double const)\n"
    "    cosmobl::barred_xi_direct(double const,std::vector< double > const,std::vector< double > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_barred_xi__direct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:barred_xi__direct",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi__direct" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi__direct" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__direct" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi__direct" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__direct" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi__direct" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "barred_xi__direct" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "barred_xi__direct" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::barred_xi__direct(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi__direct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:barred_xi__direct",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi__direct" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi__direct" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__direct" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi__direct" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__direct" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi__direct" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "barred_xi__direct" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::barred_xi__direct(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi__direct__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:barred_xi__direct",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi__direct" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi__direct" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__direct" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi__direct" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__direct" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi__direct" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::barred_xi__direct(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi__direct__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:barred_xi__direct",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi__direct" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi__direct" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__direct" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi__direct" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__direct" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::barred_xi__direct(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi__direct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_barred_xi__direct__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_barred_xi__direct__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_barred_xi__direct__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_barred_xi__direct__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'barred_xi__direct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::barred_xi__direct(double const,std::vector< double > const,std::vector< double > const,double const,double const,double const)\n"
    "    cosmobl::barred_xi__direct(double const,std::vector< double > const,std::vector< double > const,double const,double const)\n"
    "    cosmobl::barred_xi__direct(double const,std::vector< double > const,std::vector< double > const,double const)\n"
    "    cosmobl::barred_xi__direct(double const,std::vector< double > const,std::vector< double > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_barred_xi___SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:barred_xi_",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi_" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi_" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi_" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi_" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "barred_xi_" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "barred_xi_" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::barred_xi_(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi___SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:barred_xi_",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi_" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi_" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi_" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi_" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "barred_xi_" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::barred_xi_(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi___SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:barred_xi_",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi_" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi_" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi_" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi_" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::barred_xi_(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi___SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:barred_xi_",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi_" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi_" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi_" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi_" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::barred_xi_(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi_(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_barred_xi___SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_barred_xi___SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_barred_xi___SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_barred_xi___SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'barred_xi_'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::barred_xi_(double const,std::vector< double > const,std::vector< double > const,double const,double const,double const)\n"
    "    cosmobl::barred_xi_(double const,std::vector< double > const,std::vector< double > const,double const,double const)\n"
    "    cosmobl::barred_xi_(double const,std::vector< double > const,std::vector< double > const,double const)\n"
    "    cosmobl::barred_xi_(double const,std::vector< double > const,std::vector< double > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_barred_xi____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:barred_xi__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi__" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi__" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi__" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "barred_xi__" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "barred_xi__" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)cosmobl::barred_xi__(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:barred_xi__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi__" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi__" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi__" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "barred_xi__" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::barred_xi__(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:barred_xi__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi__" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi__" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "barred_xi__" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::barred_xi__(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:barred_xi__",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "barred_xi__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "barred_xi__" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "barred_xi__" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "barred_xi__" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::barred_xi__(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_barred_xi__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_barred_xi____SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_barred_xi____SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_barred_xi____SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_barred_xi____SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'barred_xi__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::barred_xi__(double const,std::vector< double > const,std::vector< double > const,double const,double const,double const)\n"
    "    cosmobl::barred_xi__(double const,std::vector< double > const,std::vector< double > const,double const,double const)\n"
    "    cosmobl::barred_xi__(double const,std::vector< double > const,std::vector< double > const,double const)\n"
    "    cosmobl::barred_xi__(double const,std::vector< double > const,std::vector< double > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_multipole_xi0__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multipole_xi0",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi0" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multipole_xi0" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi0" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multipole_xi0" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi0" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::multipole_xi0(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multipole_xi2",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi2" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multipole_xi2" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi2" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multipole_xi2" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi2" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::multipole_xi2(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multipole_xi4",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi4" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multipole_xi4" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi4" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multipole_xi4" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi4" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::multipole_xi4(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi0__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:error_multipole_xi0",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "error_multipole_xi0" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "error_multipole_xi0" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi0" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "error_multipole_xi0" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi0" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::error_multipole_xi0(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:error_multipole_xi2",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "error_multipole_xi2" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "error_multipole_xi2" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi2" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "error_multipole_xi2" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi2" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::error_multipole_xi2(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:error_multipole_xi4",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "error_multipole_xi4" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "error_multipole_xi4" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi4" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "error_multipole_xi4" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi4" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::error_multipole_xi4(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi0__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:multipole_xi0",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi0" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multipole_xi0" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi0" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multipole_xi0" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi0" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "multipole_xi0" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi0" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "multipole_xi0" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::multipole_xi0(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi0(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_multipole_xi0__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_multipole_xi0__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'multipole_xi0'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::multipole_xi0(int const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const)\n"
    "    cosmobl::multipole_xi0(double const,std::vector< double > const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_multipole_xi2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:multipole_xi2",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi2" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multipole_xi2" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi2" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multipole_xi2" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi2" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "multipole_xi2" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi2" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "multipole_xi2" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::multipole_xi2(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_multipole_xi2__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_multipole_xi2__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'multipole_xi2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::multipole_xi2(int const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const)\n"
    "    cosmobl::multipole_xi2(double const,std::vector< double > const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_multipole_xi4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:multipole_xi4",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi4" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multipole_xi4" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi4" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multipole_xi4" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi4" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "multipole_xi4" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi4" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "multipole_xi4" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::multipole_xi4(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi4(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_multipole_xi4__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_multipole_xi4__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'multipole_xi4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::multipole_xi4(int const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const)\n"
    "    cosmobl::multipole_xi4(double const,std::vector< double > const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi0__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:error_multipole_xi0",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "error_multipole_xi0" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "error_multipole_xi0" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi0" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "error_multipole_xi0" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi0" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "error_multipole_xi0" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi0" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "error_multipole_xi0" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::error_multipole_xi0(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi0(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_error_multipole_xi0__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_error_multipole_xi0__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'error_multipole_xi0'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::error_multipole_xi0(int const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const)\n"
    "    cosmobl::error_multipole_xi0(double const,std::vector< double > const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:error_multipole_xi2",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "error_multipole_xi2" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "error_multipole_xi2" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi2" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "error_multipole_xi2" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi2" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "error_multipole_xi2" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi2" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "error_multipole_xi2" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::error_multipole_xi2(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_error_multipole_xi2__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_error_multipole_xi2__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'error_multipole_xi2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::error_multipole_xi2(int const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const)\n"
    "    cosmobl::error_multipole_xi2(double const,std::vector< double > const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:error_multipole_xi4",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "error_multipole_xi4" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "error_multipole_xi4" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi4" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "error_multipole_xi4" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi4" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "error_multipole_xi4" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error_multipole_xi4" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "error_multipole_xi4" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)cosmobl::error_multipole_xi4(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_error_multipole_xi4(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_error_multipole_xi4__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_error_multipole_xi4__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'error_multipole_xi4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::error_multipole_xi4(int const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const)\n"
    "    cosmobl::error_multipole_xi4(double const,std::vector< double > const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_multipoles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::shared_ptr< void > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multipoles",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipoles" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_void_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multipoles" "', argument " "2"" of type '" "std::shared_ptr< void >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipoles" "', argument " "2"" of type '" "std::shared_ptr< void >""'");
    } else {
      std::shared_ptr< void > * temp = reinterpret_cast< std::shared_ptr< void > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multipoles" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipoles" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::multipoles(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi0_model__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:multipole_xi0_model",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi0_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multipole_xi0_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)cosmobl::multipole_xi0_model(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi0_model__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:multipole_xi0_model",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi0_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multipole_xi0_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "multipole_xi0_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "multipole_xi0_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::multipole_xi0_model(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi0_model__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::shared_ptr< void > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multipole_xi0_model",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi0_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_void_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "multipole_xi0_model" "', argument " "2"" of type '" "std::shared_ptr< void >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi0_model" "', argument " "2"" of type '" "std::shared_ptr< void >""'");
    } else {
      std::shared_ptr< void > * temp = reinterpret_cast< std::shared_ptr< void > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "multipole_xi0_model" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multipole_xi0_model" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)cosmobl::multipole_xi0_model(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi0_model(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_multipole_xi0_model__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_void_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_multipole_xi0_model__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_multipole_xi0_model__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'multipole_xi0_model'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::multipole_xi0_model(double const,double const)\n"
    "    cosmobl::multipole_xi0_model(double const,double const,double const,double const)\n"
    "    cosmobl::multipole_xi0_model(double,std::shared_ptr< void >,std::vector< double >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_multipole_xi2_model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:multipole_xi2_model",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi2_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multipole_xi2_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "multipole_xi2_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)cosmobl::multipole_xi2_model(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_multipole_xi4_model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:multipole_xi4_model",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "multipole_xi4_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multipole_xi4_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "multipole_xi4_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "multipole_xi4_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::multipole_xi4_model(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_lin_model__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  SwigValueWrapper< std::shared_ptr< void > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:xi2D_lin_model",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_lin_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_lin_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_void_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi2D_lin_model" "', argument " "3"" of type '" "std::shared_ptr< void >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "3"" of type '" "std::shared_ptr< void >""'");
    } else {
      std::shared_ptr< void > * temp = reinterpret_cast< std::shared_ptr< void > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xi2D_lin_model" "', argument " "4"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "4"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  result = (double)cosmobl::xi2D_lin_model(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_lin_model__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:xi2D_lin_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_lin_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_lin_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_lin_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_lin_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)cosmobl::xi2D_lin_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_lin_model__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  int arg9 ;
  bool arg10 ;
  double arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:xi2D_lin_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_lin_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_lin_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_lin_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_lin_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_lin_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "xi2D_lin_model" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_lin_model" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "xi2D_lin_model" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)cosmobl::xi2D_lin_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_lin_model__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  int arg9 ;
  bool arg10 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:xi2D_lin_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_lin_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_lin_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_lin_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_lin_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_lin_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "xi2D_lin_model" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_lin_model" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  result = (double)cosmobl::xi2D_lin_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_lin_model__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  int arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:xi2D_lin_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_lin_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_lin_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_lin_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_lin_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_lin_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "xi2D_lin_model" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (double)cosmobl::xi2D_lin_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_lin_model__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:xi2D_lin_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_lin_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_lin_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_lin_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_lin_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_lin_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_lin_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  result = (double)cosmobl::xi2D_lin_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_lin_model(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_void_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_xi2D_lin_model__SWIG_0(self, args);
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_xi2D_lin_model__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_xi2D_lin_model__SWIG_5(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_xi2D_lin_model__SWIG_4(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_xi2D_lin_model__SWIG_3(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_xi2D_lin_model__SWIG_2(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'xi2D_lin_model'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::xi2D_lin_model(double,double,std::shared_ptr< void >,std::vector< double >)\n"
    "    cosmobl::xi2D_lin_model(double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::xi2D_lin_model(double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,int const,bool const,double const)\n"
    "    cosmobl::xi2D_lin_model(double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,int const,bool const)\n"
    "    cosmobl::xi2D_lin_model(double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,int const)\n"
    "    cosmobl::xi2D_lin_model(double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_xi2D_model__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  SwigValueWrapper< std::shared_ptr< void > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:xi2D_model",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_void_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xi2D_model" "', argument " "3"" of type '" "std::shared_ptr< void >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "3"" of type '" "std::shared_ptr< void >""'");
    } else {
      std::shared_ptr< void > * temp = reinterpret_cast< std::shared_ptr< void > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xi2D_model" "', argument " "4"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "4"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  result = (double)cosmobl::xi2D_model(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_model__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  double arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi2D_model" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_model" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "xi2D_model" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "xi2D_model" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "xi2D_model" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "xi2D_model" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "xi2D_model" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "xi2D_model" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  result = (double)cosmobl::xi2D_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_model__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  double arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi2D_model" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_model" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "xi2D_model" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "xi2D_model" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "xi2D_model" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "xi2D_model" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "xi2D_model" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)cosmobl::xi2D_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_model__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  double arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi2D_model" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_model" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "xi2D_model" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "xi2D_model" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "xi2D_model" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "xi2D_model" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "xi2D_model" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)cosmobl::xi2D_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_model__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  double arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  double arg14 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi2D_model" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_model" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "xi2D_model" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "xi2D_model" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "xi2D_model" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "xi2D_model" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (double)cosmobl::xi2D_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_model__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  double arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi2D_model" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_model" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "xi2D_model" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "xi2D_model" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "xi2D_model" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  result = (double)cosmobl::xi2D_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_model__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  double arg10 ;
  int arg11 ;
  int arg12 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi2D_model" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_model" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "xi2D_model" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "xi2D_model" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (double)cosmobl::xi2D_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_model__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  double arg10 ;
  int arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xi2D_model" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xi2D_model" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xi2D_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xi2D_model" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xi2D_model" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "xi2D_model" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "xi2D_model" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "xi2D_model" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (double)cosmobl::xi2D_model(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_xi2D_model(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[18] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 17) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_void_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_xi2D_model__SWIG_0(self, args);
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_xi2D_model__SWIG_7(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_xi2D_model__SWIG_6(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_xi2D_model__SWIG_5(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_xi2D_model__SWIG_4(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_xi2D_model__SWIG_3(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_xi2D_model__SWIG_2(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_xi2D_model__SWIG_1(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'xi2D_model'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::xi2D_model(double,double,std::shared_ptr< void >,std::vector< double >)\n"
    "    cosmobl::xi2D_model(double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,int const,int,bool const,double const,double const,double const,int const)\n"
    "    cosmobl::xi2D_model(double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,int const,int,bool const,double const,double const,double const)\n"
    "    cosmobl::xi2D_model(double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,int const,int,bool const,double const,double const)\n"
    "    cosmobl::xi2D_model(double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,int const,int,bool const,double const)\n"
    "    cosmobl::xi2D_model(double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,int const,int,bool const)\n"
    "    cosmobl::xi2D_model(double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,int const,int)\n"
    "    cosmobl::xi2D_model(double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_f_v__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  int arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:f_v",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "f_v" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "f_v" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "f_v" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)cosmobl::f_v(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_f_v__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:f_v",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "f_v" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "f_v" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "f_v" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "f_v" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "f_v" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "f_v" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "f_v" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "f_v" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)cosmobl::f_v(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_f_v(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_f_v__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_f_v__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'f_v'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::f_v(double const,double const,int const)\n"
    "    cosmobl::f_v(double const,double const,double const,double const,double const,double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_f_star(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:f_star",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "f_star" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "f_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "f_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)cosmobl::f_star(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_b_nl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:b_nl",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "b_nl" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "b_nl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "b_nl" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "b_nl" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)cosmobl::b_nl(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_b_nl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:b_nl",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "b_nl" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "b_nl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "b_nl" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)cosmobl::b_nl(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_b_nl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:b_nl",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "b_nl" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "b_nl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)cosmobl::b_nl(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_b_nl(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_b_nl__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_b_nl__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_b_nl__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'b_nl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::b_nl(double const,double const,double const,double const)\n"
    "    cosmobl::b_nl(double const,double const,double const)\n"
    "    cosmobl::b_nl(double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_relative_error_beta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:relative_error_beta",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "relative_error_beta" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "relative_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "relative_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)cosmobl::relative_error_beta(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid__xx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid *arg1 = (cosmobl::glob::STR_grid *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_grid__xx_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid__xx_set" "', argument " "1"" of type '" "cosmobl::glob::STR_grid *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_grid__xx_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->_xx = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid__xx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid *arg1 = (cosmobl::glob::STR_grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_grid__xx_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid__xx_get" "', argument " "1"" of type '" "cosmobl::glob::STR_grid *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid * >(argp1);
  result = (std::vector< double > *)& ((arg1)->_xx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid__yy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid *arg1 = (cosmobl::glob::STR_grid *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_grid__yy_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid__yy_set" "', argument " "1"" of type '" "cosmobl::glob::STR_grid *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_grid__yy_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->_yy = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid__yy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid *arg1 = (cosmobl::glob::STR_grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_grid__yy_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid__yy_get" "', argument " "1"" of type '" "cosmobl::glob::STR_grid *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid * >(argp1);
  result = (std::vector< double > *)& ((arg1)->_yy);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_grid")) SWIG_fail;
  result = (cosmobl::glob::STR_grid *)new cosmobl::glob::STR_grid();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_grid, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid *arg1 = (cosmobl::glob::STR_grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_grid",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_grid" "', argument " "1"" of type '" "cosmobl::glob::STR_grid *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_grid, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_grid_2D__xx1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid_2D *arg1 = (cosmobl::glob::STR_grid_2D *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_grid_2D__xx1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid_2D__xx1_set" "', argument " "1"" of type '" "cosmobl::glob::STR_grid_2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid_2D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_grid_2D__xx1_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->_xx1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid_2D__xx1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid_2D *arg1 = (cosmobl::glob::STR_grid_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_grid_2D__xx1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid_2D__xx1_get" "', argument " "1"" of type '" "cosmobl::glob::STR_grid_2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid_2D * >(argp1);
  result = (std::vector< double > *)& ((arg1)->_xx1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid_2D__xx2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid_2D *arg1 = (cosmobl::glob::STR_grid_2D *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_grid_2D__xx2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid_2D__xx2_set" "', argument " "1"" of type '" "cosmobl::glob::STR_grid_2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid_2D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_grid_2D__xx2_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->_xx2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid_2D__xx2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid_2D *arg1 = (cosmobl::glob::STR_grid_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_grid_2D__xx2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid_2D__xx2_get" "', argument " "1"" of type '" "cosmobl::glob::STR_grid_2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid_2D * >(argp1);
  result = (std::vector< double > *)& ((arg1)->_xx2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid_2D__yy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid_2D *arg1 = (cosmobl::glob::STR_grid_2D *) 0 ;
  std::vector< std::vector< double > > *arg2 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_grid_2D__yy_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid_2D__yy_set" "', argument " "1"" of type '" "cosmobl::glob::STR_grid_2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid_2D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_grid_2D__yy_set" "', argument " "2"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  if (arg1) (arg1)->_yy = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_grid_2D__yy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid_2D *arg1 = (cosmobl::glob::STR_grid_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_grid_2D__yy_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_grid_2D__yy_get" "', argument " "1"" of type '" "cosmobl::glob::STR_grid_2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid_2D * >(argp1);
  result = (std::vector< std::vector< double > > *)& ((arg1)->_yy);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_grid_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid_2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_grid_2D")) SWIG_fail;
  result = (cosmobl::glob::STR_grid_2D *)new cosmobl::glob::STR_grid_2D();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_grid_2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_grid_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_grid_2D *arg1 = (cosmobl::glob::STR_grid_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_grid_2D",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_grid_2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_grid_2D" "', argument " "1"" of type '" "cosmobl::glob::STR_grid_2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_grid_2D * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_grid_2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_grid_2D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_xi0_model_bias_sigma8_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0_model *arg1 = (cosmobl::glob::STR_xi0_model *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0_model_bias_sigma8_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0_model_bias_sigma8_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0_model * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0_model_bias_sigma8_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->bias_sigma8 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0_model_bias_sigma8_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0_model *arg1 = (cosmobl::glob::STR_xi0_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0_model_bias_sigma8_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0_model_bias_sigma8_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0_model * >(argp1);
  result = (double) ((arg1)->bias_sigma8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0_model_sigma8z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0_model *arg1 = (cosmobl::glob::STR_xi0_model *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0_model_sigma8z_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0_model_sigma8z_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0_model * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0_model_sigma8z_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigma8z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0_model_sigma8z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0_model *arg1 = (cosmobl::glob::STR_xi0_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0_model_sigma8z_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0_model_sigma8z_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0_model * >(argp1);
  result = (double) ((arg1)->sigma8z);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0_model_xi_DM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0_model *arg1 = (cosmobl::glob::STR_xi0_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0_model_xi_DM_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0_model_xi_DM_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi0_model_xi_DM_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->xi_DM = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0_model_xi_DM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0_model *arg1 = (cosmobl::glob::STR_xi0_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0_model_xi_DM_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0_model_xi_DM_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->xi_DM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_xi0_model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0_model *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_xi0_model")) SWIG_fail;
  result = (cosmobl::glob::STR_xi0_model *)new cosmobl::glob::STR_xi0_model();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_xi0_model, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_xi0_model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0_model *arg1 = (cosmobl::glob::STR_xi0_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_xi0_model",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0_model, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_xi0_model" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0_model * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_xi0_model_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_xi0_model, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_xi2D_model_rp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_rp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_rp_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_rp_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->rp = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_rp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_rp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_rp_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->rp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_pi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_pi_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_pi_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_pi_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->pi = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_pi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_pi_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_pi_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->pi);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_xi_real_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_xi_real_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_xi_real_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_xi_real_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->xi_real = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_xi_real_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_xi_real_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_xi_real_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->xi_real);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_xi__set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_xi__set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_xi__set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_xi__set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->xi_ = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_xi__get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_xi__get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_xi__get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->xi_);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_xi___set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_xi___set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_xi___set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_xi___set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->xi__ = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_xi___get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_xi___get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_xi___get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->xi__);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_P2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_P2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_P2_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_P2_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->P2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_P2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_P2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_P2_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->P2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_P4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_P4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_P4_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_P4_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->P4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_P4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_P4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_P4_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->P4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_vel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_vel_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_vel_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_vel_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->vel = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_vel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_vel_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_vel_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< double > *)& ((arg1)->vel);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_lim_index_fit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< int > *arg2 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_lim_index_fit_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_lim_index_fit_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_lim_index_fit_set" "', argument " "2"" of type '" "std::vector< int > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
  if (arg1) (arg1)->lim_index_fit = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_lim_index_fit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_lim_index_fit_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_lim_index_fit_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< int > *)& ((arg1)->lim_index_fit);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  std::vector< int > *arg2 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_type_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_type_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi2D_model_type_set" "', argument " "2"" of type '" "std::vector< int > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
  if (arg1) (arg1)->type = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_type_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_type_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (std::vector< int > *)& ((arg1)->type);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_step_v_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_step_v_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_step_v_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi2D_model_step_v_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->step_v = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_step_v_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_step_v_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_step_v_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (int) ((arg1)->step_v);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_FV_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_FV_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_FV_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi2D_model_FV_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->FV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_FV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_FV_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_FV_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (int) ((arg1)->FV);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_dim_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_dim_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_dim_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi2D_model_dim_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->dim = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_dim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_dim_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_dim_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (int) ((arg1)->dim);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_delta_v_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_delta_v_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_delta_v_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi2D_model_delta_v_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->delta_v = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_delta_v_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_delta_v_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_delta_v_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (double) ((arg1)->delta_v);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_bias_nl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi2D_model_bias_nl_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_bias_nl_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi2D_model_bias_nl_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->bias_nl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi2D_model_bias_nl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi2D_model_bias_nl_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi2D_model_bias_nl_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  result = (bool) ((arg1)->bias_nl);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_xi2D_model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_xi2D_model")) SWIG_fail;
  result = (cosmobl::glob::STR_xi2D_model *)new cosmobl::glob::STR_xi2D_model();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_xi2D_model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi2D_model *arg1 = (cosmobl::glob::STR_xi2D_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_xi2D_model",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_xi2D_model" "', argument " "1"" of type '" "cosmobl::glob::STR_xi2D_model *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi2D_model * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_xi2D_model_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_xi2D_model, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_xi_rr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_rr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_rr_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_rr_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->rr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_rr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_rr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_rr_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  result = (double) ((arg1)->rr);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_aa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_aa_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_aa_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_aa_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->aa = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_aa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_aa_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_aa_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  result = (double) ((arg1)->aa);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_lgkk_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_lgkk_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_lgkk_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi_lgkk_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->lgkk = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_lgkk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_lgkk_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_lgkk_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  result = (std::vector< double > *)& ((arg1)->lgkk);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_lgPk_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_lgPk_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_lgPk_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi_lgPk_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->lgPk = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_lgPk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_lgPk_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_lgPk_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  result = (std::vector< double > *)& ((arg1)->lgPk);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_xi")) SWIG_fail;
  result = (cosmobl::glob::STR_xi *)new cosmobl::glob::STR_xi();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_xi, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi *arg1 = (cosmobl::glob::STR_xi *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_xi",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_xi" "', argument " "1"" of type '" "cosmobl::glob::STR_xi *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_xi_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_xi, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_SSM_unit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_unit_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_unit_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_unit_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->unit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_unit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_unit_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_unit_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  result = (int) ((arg1)->unit);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_hh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_hh_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_hh_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_hh_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->hh = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_hh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_hh_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_hh_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  result = (double) ((arg1)->hh);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_mass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_mass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_mass_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_mass_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_mass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_mass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_mass_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  result = (double) ((arg1)->mass);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_rho_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_rho_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_rho_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_rho_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->rho = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_rho_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_rho_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_rho_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  result = (double) ((arg1)->rho);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_n_spec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_n_spec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_n_spec_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_n_spec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->n_spec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_n_spec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_n_spec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_n_spec_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  result = (double) ((arg1)->n_spec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_lgkk_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_lgkk_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_lgkk_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_SSM_lgkk_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->lgkk = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_lgkk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_lgkk_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_lgkk_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  result = (std::vector< double > *)& ((arg1)->lgkk);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_lgPk_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_lgPk_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_lgPk_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_SSM_lgPk_set" "', argument " "2"" of type '" "std::vector< double > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  if (arg1) (arg1)->lgPk = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_lgPk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_lgPk_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_lgPk_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  result = (std::vector< double > *)& ((arg1)->lgPk);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_SSM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_SSM")) SWIG_fail;
  result = (cosmobl::glob::STR_SSM *)new cosmobl::glob::STR_SSM();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_SSM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_SSM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM *arg1 = (cosmobl::glob::STR_SSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_SSM",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_SSM" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_SSM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_SSM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_yotta_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable yotta is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_yotta_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(yotta));
  return pyobj;
}


SWIGINTERN int Swig_var_zetta_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable zetta is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_zetta_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(zetta));
  return pyobj;
}


SWIGINTERN int Swig_var_exa_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable exa is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_exa_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(exa));
  return pyobj;
}


SWIGINTERN int Swig_var_peta_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable peta is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_peta_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(peta));
  return pyobj;
}


SWIGINTERN int Swig_var_tera_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable tera is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_tera_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(tera));
  return pyobj;
}


SWIGINTERN int Swig_var_giga_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable giga is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_giga_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(giga));
  return pyobj;
}


SWIGINTERN int Swig_var_mega_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mega is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mega_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(mega));
  return pyobj;
}


SWIGINTERN int Swig_var_kilo_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable kilo is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_kilo_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(kilo));
  return pyobj;
}


SWIGINTERN int Swig_var_ecto_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ecto is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ecto_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(ecto));
  return pyobj;
}


SWIGINTERN int Swig_var_deca_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable deca is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_deca_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(deca));
  return pyobj;
}


SWIGINTERN int Swig_var_deci_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable deci is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_deci_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(deci));
  return pyobj;
}


SWIGINTERN int Swig_var_centi_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable centi is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_centi_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(centi));
  return pyobj;
}


SWIGINTERN int Swig_var_milli_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable milli is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_milli_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(milli));
  return pyobj;
}


SWIGINTERN int Swig_var_micro_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable micro is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_micro_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(micro));
  return pyobj;
}


SWIGINTERN int Swig_var_nano_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable nano is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_nano_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(nano));
  return pyobj;
}


SWIGINTERN int Swig_var_pico_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable pico is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_pico_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(pico));
  return pyobj;
}


SWIGINTERN int Swig_var_femto_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable femto is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_femto_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(femto));
  return pyobj;
}


SWIGINTERN int Swig_var_atto_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable atto is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_atto_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(atto));
  return pyobj;
}


SWIGINTERN int Swig_var_zepto_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable zepto is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_zepto_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(zepto));
  return pyobj;
}


SWIGINTERN int Swig_var_yocto_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable yocto is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_yocto_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(yocto));
  return pyobj;
}


SWIGINTERN int Swig_var_fINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fINT);
  return pyobj;
}


SWIGINTERN int Swig_var_fLONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fLONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fLONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fLONG);
  return pyobj;
}


SWIGINTERN int Swig_var_fDP0_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fDP0 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fDP0_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fDP0);
  return pyobj;
}


SWIGINTERN int Swig_var_fDP1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fDP1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fDP1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fDP1);
  return pyobj;
}


SWIGINTERN int Swig_var_fDP2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fDP2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fDP2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fDP2);
  return pyobj;
}


SWIGINTERN int Swig_var_fDP3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fDP3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fDP3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fDP3);
  return pyobj;
}


SWIGINTERN int Swig_var_fDP4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fDP4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fDP4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fDP4);
  return pyobj;
}


SWIGINTERN int Swig_var_fDP5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fDP5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fDP5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fDP5);
  return pyobj;
}


SWIGINTERN int Swig_var_fDP6_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable fDP6 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_fDP6_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(fDP6);
  return pyobj;
}


SWIGINTERN int Swig_var_ee3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ee3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ee3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(ee3);
  return pyobj;
}


SWIGINTERN int Swig_var_pi_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable pi is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_pi_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(pi));
  return pyobj;
}


SWIGINTERN int Swig_var_ee_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ee is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ee_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(ee));
  return pyobj;
}


SWIGINTERN int Swig_var_hbar_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable hbar is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_hbar_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(hbar));
  return pyobj;
}


SWIGINTERN int Swig_var_cc_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable cc is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_cc_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(cc));
  return pyobj;
}


SWIGINTERN int Swig_var_kB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable kB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_kB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(kB));
  return pyobj;
}


SWIGINTERN int Swig_var_sSB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable sSB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_sSB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(sSB));
  return pyobj;
}


SWIGINTERN int Swig_var_el_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable el is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_el_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(el));
  return pyobj;
}


SWIGINTERN int Swig_var_alpha_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable alpha is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_alpha_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(alpha));
  return pyobj;
}


SWIGINTERN int Swig_var_epsilon0_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable epsilon0 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_epsilon0_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(epsilon0));
  return pyobj;
}


SWIGINTERN int Swig_var_mu0_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mu0 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mu0_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(mu0));
  return pyobj;
}


SWIGINTERN int Swig_var_NAv_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NAv is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NAv_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(NAv));
  return pyobj;
}


SWIGINTERN int Swig_var_GN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(GN));
  return pyobj;
}


SWIGINTERN int Swig_var_gn_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable gn is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_gn_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(gn));
  return pyobj;
}


SWIGINTERN int Swig_var_lP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable lP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_lP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(lP));
  return pyobj;
}


SWIGINTERN int Swig_var_MP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(MP));
  return pyobj;
}


SWIGINTERN int Swig_var_Msol_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Msol is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Msol_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Msol));
  return pyobj;
}


SWIGINTERN int Swig_var_me_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable me is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_me_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(me));
  return pyobj;
}


SWIGINTERN int Swig_var_mn_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mn is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mn_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(mn));
  return pyobj;
}


SWIGINTERN int Swig_var_mp_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mp is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mp_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(mp));
  return pyobj;
}


SWIGINTERN int Swig_var_au_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable au is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_au_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(au));
  return pyobj;
}


SWIGINTERN int Swig_var_pc_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable pc is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_pc_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(pc));
  return pyobj;
}


SWIGINTERN int Swig_var_TCMB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TCMB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TCMB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(TCMB));
  return pyobj;
}


SWIGINTERN int Swig_var_yr_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable yr is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_yr_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(yr));
  return pyobj;
}


SWIGINTERN int Swig_var_col_default_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable col_default is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_col_default_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(col_default));
  return pyobj;
}


SWIGINTERN int Swig_var_col_red_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable col_red is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_col_red_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(col_red));
  return pyobj;
}


SWIGINTERN int Swig_var_col_green_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable col_green is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_col_green_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(col_green));
  return pyobj;
}


SWIGINTERN int Swig_var_col_blue_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable col_blue is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_col_blue_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_std_string(static_cast< std::string >(col_blue));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Cosmology",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Cosmology" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cosmology" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Cosmology",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Cosmology" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Cosmology")) SWIG_fail;
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  int arg14 ;
  std::string arg15 ;
  bool arg16 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_Cosmology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cosmology" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cosmology" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cosmology" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cosmology" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cosmology" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cosmology" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Cosmology" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Cosmology" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Cosmology" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Cosmology" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Cosmology" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Cosmology" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_Cosmology" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_Cosmology" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Cosmology" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_Cosmology" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  int arg14 ;
  std::string arg15 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_Cosmology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cosmology" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cosmology" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cosmology" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cosmology" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cosmology" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cosmology" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Cosmology" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Cosmology" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Cosmology" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Cosmology" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Cosmology" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Cosmology" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_Cosmology" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_Cosmology" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Cosmology" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  int arg14 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:new_Cosmology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cosmology" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cosmology" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cosmology" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cosmology" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cosmology" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cosmology" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Cosmology" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Cosmology" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Cosmology" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Cosmology" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Cosmology" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Cosmology" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_Cosmology" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_Cosmology" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_Cosmology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cosmology" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cosmology" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cosmology" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cosmology" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cosmology" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cosmology" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Cosmology" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Cosmology" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Cosmology" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Cosmology" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Cosmology" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Cosmology" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_Cosmology" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_Cosmology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cosmology" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cosmology" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cosmology" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cosmology" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cosmology" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cosmology" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Cosmology" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Cosmology" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Cosmology" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Cosmology" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Cosmology" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Cosmology" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_Cosmology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cosmology" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cosmology" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cosmology" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cosmology" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cosmology" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cosmology" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Cosmology" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Cosmology" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Cosmology" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Cosmology" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Cosmology" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_Cosmology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cosmology" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cosmology" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cosmology" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cosmology" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cosmology" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cosmology" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Cosmology" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Cosmology" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Cosmology" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Cosmology" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (cosmobl::Cosmology *)new cosmobl::Cosmology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cosmology(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[17] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 16) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Cosmology__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Cosmology__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Cosmology__SWIG_0(self, args);
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_Cosmology__SWIG_9(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_Cosmology__SWIG_8(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_Cosmology__SWIG_7(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_Cosmology__SWIG_6(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_Cosmology__SWIG_5(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_Cosmology__SWIG_4(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_Cosmology__SWIG_3(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Cosmology'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Cosmology(std::string const,bool const)\n"
    "    cosmobl::Cosmology::Cosmology(std::string const)\n"
    "    cosmobl::Cosmology::Cosmology()\n"
    "    cosmobl::Cosmology::Cosmology(double const,double const,double const,double const,int const,double const,double const,double const,double const,double const,double const,double const,double const,int const,std::string const,bool const)\n"
    "    cosmobl::Cosmology::Cosmology(double const,double const,double const,double const,int const,double const,double const,double const,double const,double const,double const,double const,double const,int const,std::string const)\n"
    "    cosmobl::Cosmology::Cosmology(double const,double const,double const,double const,int const,double const,double const,double const,double const,double const,double const,double const,double const,int const)\n"
    "    cosmobl::Cosmology::Cosmology(double const,double const,double const,double const,int const,double const,double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::Cosmology(double const,double const,double const,double const,int const,double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::Cosmology(double const,double const,double const,double const,int const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::Cosmology(double const,double const,double const,double const,int const,double const,double const,double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Cosmology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Cosmology",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cosmology" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Omega_matter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Omega_matter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Omega_matter" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Omega_matter();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Omega_baryon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Omega_baryon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Omega_baryon" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Omega_baryon();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Omega_neutrinos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Omega_neutrinos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Omega_neutrinos" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Omega_neutrinos();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_massless_neutrinos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_massless_neutrinos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_massless_neutrinos" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->massless_neutrinos();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_massive_neutrinos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_massive_neutrinos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_massive_neutrinos" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (int)((cosmobl::Cosmology const *)arg1)->massive_neutrinos();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Omega_DE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Omega_DE",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Omega_DE" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Omega_DE();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Omega_radiation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Omega_radiation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Omega_radiation" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Omega_radiation();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Omega_k(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Omega_k",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Omega_k" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Omega_k();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Omega_CDM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Omega_CDM",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Omega_CDM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Omega_CDM();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_H0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_H0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_H0" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->H0();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_hh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_hh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_hh" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->hh();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_t_H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_t_H",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_t_H" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->t_H();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_D_H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_D_H",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_D_H" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->D_H();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_sigma8",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_scalar_amp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_scalar_amp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_scalar_amp" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->scalar_amp();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_spec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_n_spec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_n_spec" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->n_spec();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_w0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_w0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_w0" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->w0();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_wa",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wa" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->wa();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_RhoZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_RhoZero",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_RhoZero" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->RhoZero();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fNL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_fNL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fNL" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->fNL();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_type_NG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_type_NG",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_type_NG" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (int)((cosmobl::Cosmology const *)arg1)->type_NG();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk0_EH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Pk0_EH",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk0_EH" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Pk0_EH();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk0_CAMB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Pk0_CAMB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk0_CAMB" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Pk0_CAMB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk0_MPTbreeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Pk0_MPTbreeze",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk0_MPTbreeze" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Pk0_MPTbreeze();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk0_CLASS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_Pk0_CLASS",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk0_CLASS" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->Pk0_CLASS();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_model",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_model" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = ((cosmobl::Cosmology const *)arg1)->model();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_unit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_unit" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (bool)((cosmobl::Cosmology const *)arg1)->unit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_print_parameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_print_parameters",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_print_parameters" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ((cosmobl::Cosmology const *)arg1)->print_parameters();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_Omega(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_Omega",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_Omega" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_Omega" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_Omega(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_OmegaB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_OmegaB",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_OmegaB" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_OmegaB" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_OmegaB(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_OmegaM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_OmegaM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_OmegaM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_OmegaM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_OmegaM(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_OmegaDE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_OmegaDE",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_OmegaDE" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_OmegaDE" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_OmegaDE(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_OmegaNu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_set_OmegaNu",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_OmegaNu" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_OmegaNu" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_set_OmegaNu" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_set_OmegaNu" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->set_OmegaNu(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_H0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_H0",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_H0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_H0" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_H0(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_sigma8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_sigma8",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_sigma8" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_sigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_sigma8(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_scalar_amp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_scalar_amp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_scalar_amp" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_scalar_amp" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_scalar_amp(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_w0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_w0",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_w0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_w0" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_w0(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_wa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_wa",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_wa" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_wa" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_wa(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_RhoZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_RhoZero",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_RhoZero" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_RhoZero" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_RhoZero(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_fNL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_fNL",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_fNL" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_fNL" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_fNL(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_type_NG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_type_NG",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_type_NG" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_type_NG" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_type_NG(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_model",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_model" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_set_model" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->set_model(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_set_unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_set_unit",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_set_unit" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_set_unit" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->set_unit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_OmegaM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_OmegaM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_OmegaM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_OmegaM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->OmegaM(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_OmegaDE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_OmegaDE",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_OmegaDE" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_OmegaDE" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->OmegaDE(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_OmegaR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_OmegaR",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_OmegaR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_OmegaR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->OmegaR(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_OmegaK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_OmegaK",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_OmegaK" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_OmegaK" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->OmegaK(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Omega(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_Omega",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Omega" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Omega" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->Omega(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Rho__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Rho",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Rho" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Rho" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Rho" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Rho" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->Rho(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Rho__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_Rho",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Rho" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Rho" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Rho" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->Rho(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Rho(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_Rho__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_Rho__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Rho'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Rho(double const,double const,bool const) const\n"
    "    cosmobl::Cosmology::Rho(double const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_DeltaR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_DeltaR",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_DeltaR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_DeltaR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_DeltaR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->DeltaR(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_w_CPL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_w_CPL",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_w_CPL" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_w_CPL" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->w_CPL(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_f_DE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_f_DE",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_f_DE" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_f_DE" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->f_DE(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_EE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_EE",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_EE" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_EE" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->EE(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_HH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_HH",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_HH" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_HH" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->HH(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_gg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_gg",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_gg" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_gg" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->gg(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_DD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_DD",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_DD" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_DD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->DD(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_lookback_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_lookback_time",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_lookback_time" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_lookback_time" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->lookback_time(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_cosmic_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_cosmic_time",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_cosmic_time" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_cosmic_time" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->cosmic_time(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_EE2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_EE2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_EE2" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_EE2" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->EE2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_qq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_qq",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_qq" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_qq" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->qq(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Hdot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_Hdot",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Hdot" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Hdot" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->Hdot(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_z_acc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_z_acc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_z_acc" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->z_acc();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_z_eq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_z_eq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_z_eq" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->z_eq();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Mag_Volume_limited(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_Mag_Volume_limited",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Mag_Volume_limited" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Mag_Volume_limited" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Mag_Volume_limited" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->Mag_Volume_limited(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Lum_bol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_Lum_bol",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Lum_bol" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Lum_bol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Lum_bol" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->Lum_bol(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_Redshift",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Redshift" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Redshift" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Redshift" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Redshift" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Redshift" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->Redshift(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Redshift",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Redshift" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Redshift" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Redshift" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Redshift" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->Redshift(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift_LCDM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_Redshift_LCDM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Redshift_LCDM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Redshift_LCDM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Redshift_LCDM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Redshift_LCDM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Redshift_LCDM" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Redshift_LCDM" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->Redshift_LCDM(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift_LCDM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_Redshift_LCDM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Redshift_LCDM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Redshift_LCDM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Redshift_LCDM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Redshift_LCDM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Redshift_LCDM" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->Redshift_LCDM(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift_LCDM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Redshift_LCDM",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Redshift_LCDM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Redshift_LCDM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Redshift_LCDM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Redshift_LCDM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->Redshift_LCDM(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift_LCDM(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_Redshift_LCDM__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_Redshift_LCDM__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_Redshift_LCDM__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Redshift_LCDM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Redshift_LCDM(double const,double const,double const,bool const,double const) const\n"
    "    cosmobl::Cosmology::Redshift_LCDM(double const,double const,double const,bool const) const\n"
    "    cosmobl::Cosmology::Redshift_LCDM(double const,double const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_Redshift",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Redshift" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Redshift" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Redshift" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Redshift" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Redshift" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Redshift" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Redshift" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Redshift(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_Redshift",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Redshift" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Redshift" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Redshift" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Redshift" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Redshift" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Redshift" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->Redshift(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_Redshift__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_Redshift__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_Redshift__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_Redshift__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Redshift'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Redshift(double const,double const,double const,double const) const\n"
    "    cosmobl::Cosmology::Redshift(double const,double const,double const) const\n"
    "    cosmobl::Cosmology::Redshift(double const,double const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::Redshift(double const,double const,double const,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_Redshift_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Redshift_time",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Redshift_time" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Redshift_time" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Redshift_time" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Redshift_time" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->Redshift_time(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_deltac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_deltac",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_deltac" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_deltac" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->deltac(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Deltavir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_Deltavir",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Deltavir" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Deltavir" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->Deltavir(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_D_C(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_D_C",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_D_C" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_D_C" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->D_C(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_D_C_LCDM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_D_C_LCDM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_D_C_LCDM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_D_C_LCDM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->D_C_LCDM(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_D_C_table(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_D_C_table",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_D_C_table" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_D_C_table" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_D_C_table" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_D_C_table" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_D_C_table" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Cosmology_D_C_table" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_D_C_table" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_D_C_table" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_D_C_table" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  ((cosmobl::Cosmology const *)arg1)->D_C_table(arg2,arg3,arg4,arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_D_M(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_D_M",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_D_M" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_D_M" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->D_M(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_D_A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_D_A",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_D_A" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_D_A" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->D_A(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_D_L(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_D_L",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_D_L" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_D_L" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->D_L(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_D_V(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_D_V",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_D_V" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_D_V" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->D_V(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_Distance",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Distance" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Distance" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Distance" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Distance(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Volume__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Volume",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Volume" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Volume" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Volume" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Volume" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->Volume(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Volume__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_Volume",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Volume" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Volume" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->Volume(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Volume(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Cosmology_Volume__SWIG_1(self, args);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_Volume__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Volume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Volume(double const,double const,double const) const\n"
    "    cosmobl::Cosmology::Volume(double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_max_redshift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_max_redshift",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_max_redshift" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_max_redshift" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_max_redshift" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_max_redshift" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->max_redshift(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dV_dZdOmega(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_dV_dZdOmega",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dV_dZdOmega" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dV_dZdOmega" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dV_dZdOmega" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->dV_dZdOmega(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  std::string arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_mass_function" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj15, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "16"" of type '" "std::string const""'"); 
    }
    arg16 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_mass_function" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  std::string arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function_fast" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function_fast" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function_fast" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function_fast" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function_fast" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function_fast" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_mass_function_fast" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj15, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "16"" of type '" "std::string const""'"); 
    }
    arg16 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function_fast" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function_fast" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function_fast" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function_fast" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function_fast" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function_fast" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_mass_function_fast" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function_fast" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function_fast" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function_fast" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function_fast" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function_fast" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function_fast" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function_fast" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function_fast" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function_fast" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function_fast" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function_fast" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function_fast" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function_fast" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function_fast" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function_fast" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function_fast" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function_fast" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function_fast" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function_fast" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function_fast" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mass_function_fast" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mass_function_fast" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_mass_function_fast",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function_fast" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function_fast" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function_fast" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function_fast" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function_fast(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function_fast(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[17] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 16) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_mass_function_fast__SWIG_11(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_mass_function_fast__SWIG_10(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_mass_function_fast__SWIG_9(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_mass_function_fast__SWIG_8(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_mass_function_fast__SWIG_7(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_mass_function_fast__SWIG_6(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_mass_function_fast__SWIG_5(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_mass_function_fast__SWIG_4(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_mass_function_fast__SWIG_3(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_mass_function_fast__SWIG_2(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_mass_function_fast__SWIG_1(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_AsPtr_std_string(argv[15], (std::string**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_Cosmology_mass_function_fast__SWIG_0(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_mass_function_fast'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function_fast(double const,double const,std::string const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  bool arg15 ;
  double arg16 ;
  std::string arg17 ;
  std::string arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_mass_function" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_mass_function" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj16, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "17"" of type '" "std::string const""'"); 
    }
    arg17 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj17, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "18"" of type '" "std::string const""'"); 
    }
    arg18 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  bool arg15 ;
  double arg16 ;
  std::string arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_mass_function" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_mass_function" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj16, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "17"" of type '" "std::string const""'"); 
    }
    arg17 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  bool arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_mass_function" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_mass_function" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_mass_function" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_mass_function" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  int arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_mass_function" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  int arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_mass_function" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_mass_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mass_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_22(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mass_function" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_23(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function__SWIG_24(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_mass_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mass_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_mass_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_mass_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mass_function" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mass_function(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mass_function(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[19] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 18) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_mass_function__SWIG_11(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_mass_function__SWIG_24(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_mass_function__SWIG_10(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_mass_function__SWIG_23(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_mass_function__SWIG_9(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_mass_function__SWIG_22(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_mass_function__SWIG_8(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Cosmology_mass_function__SWIG_21(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_mass_function__SWIG_7(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_mass_function__SWIG_20(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_mass_function__SWIG_6(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_mass_function__SWIG_19(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_mass_function__SWIG_5(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_mass_function__SWIG_18(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_mass_function__SWIG_4(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_mass_function__SWIG_17(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_mass_function__SWIG_3(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_mass_function__SWIG_16(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_mass_function__SWIG_2(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_mass_function__SWIG_15(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_mass_function__SWIG_1(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_mass_function__SWIG_14(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_AsPtr_std_string(argv[15], (std::string**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_Cosmology_mass_function__SWIG_0(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    int res = SWIG_AsPtr_std_string(argv[16], (std::string**)(0));
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_Cosmology_mass_function__SWIG_13(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    int res = SWIG_AsPtr_std_string(argv[16], (std::string**)(0));
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = SWIG_AsPtr_std_string(argv[17], (std::string**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_Cosmology_mass_function__SWIG_12(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_mass_function'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::mass_function(double const,double const,double const,double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_haloes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  std::string arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_n_haloes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_n_haloes" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_n_haloes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_n_haloes" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_n_haloes" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_n_haloes" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_n_haloes" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_n_haloes" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_n_haloes" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_n_haloes" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj13, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "14"" of type '" "std::string const""'"); 
    }
    arg14 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->n_haloes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_haloes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_n_haloes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_n_haloes" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_n_haloes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_n_haloes" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_n_haloes" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_n_haloes" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_n_haloes" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_n_haloes" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_n_haloes" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_n_haloes" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->n_haloes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_haloes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_n_haloes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_n_haloes" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_n_haloes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_n_haloes" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_n_haloes" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_n_haloes" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_n_haloes" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_n_haloes" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_n_haloes" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->n_haloes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_haloes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_n_haloes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_n_haloes" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_n_haloes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_n_haloes" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_n_haloes" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_n_haloes" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_n_haloes" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_n_haloes" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (double)(arg1)->n_haloes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_haloes__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_n_haloes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_n_haloes" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_n_haloes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_n_haloes" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_n_haloes" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_n_haloes" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_n_haloes" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->n_haloes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_haloes__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_n_haloes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_n_haloes" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_n_haloes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_n_haloes" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_n_haloes" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_n_haloes" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_n_haloes" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->n_haloes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_haloes__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_n_haloes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_n_haloes" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_n_haloes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_n_haloes" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_n_haloes" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_n_haloes" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_n_haloes" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_n_haloes" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->n_haloes(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_n_haloes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[15] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 14) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_n_haloes__SWIG_6(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Cosmology_n_haloes__SWIG_5(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_n_haloes__SWIG_4(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_n_haloes__SWIG_3(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_n_haloes__SWIG_2(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_n_haloes__SWIG_1(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_AsPtr_std_string(argv[13], (std::string**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_Cosmology_n_haloes__SWIG_0(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_n_haloes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::n_haloes(double const,double const,double const,double const,bool const,std::string const,std::string const,std::string const,std::string const,int const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::n_haloes(double const,double const,double const,double const,bool const,std::string const,std::string const,std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::n_haloes(double const,double const,double const,double const,bool const,std::string const,std::string const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::n_haloes(double const,double const,double const,double const,bool const,std::string const,std::string const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::n_haloes(double const,double const,double const,double const,bool const,std::string const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::n_haloes(double const,double const,double const,double const,bool const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::n_haloes(double const,double const,double const,double const,bool const,std::string const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_MhaloMin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  std::string arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  std::string arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MhaloMin" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MhaloMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MhaloMin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_MhaloMin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_MhaloMin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_MhaloMin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MhaloMin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MhaloMin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MhaloMin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_MhaloMin" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_MhaloMin" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_MhaloMin" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj16, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "17"" of type '" "std::string const""'"); 
    }
    arg17 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->MhaloMin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MhaloMin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  std::string arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MhaloMin" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MhaloMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MhaloMin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_MhaloMin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_MhaloMin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_MhaloMin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MhaloMin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MhaloMin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MhaloMin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_MhaloMin" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_MhaloMin" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_MhaloMin" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)((cosmobl::Cosmology const *)arg1)->MhaloMin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MhaloMin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  std::string arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MhaloMin" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MhaloMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MhaloMin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_MhaloMin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_MhaloMin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_MhaloMin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MhaloMin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MhaloMin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MhaloMin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_MhaloMin" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_MhaloMin" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)((cosmobl::Cosmology const *)arg1)->MhaloMin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MhaloMin__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  std::string arg12 ;
  std::string arg13 ;
  int arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MhaloMin" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MhaloMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MhaloMin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_MhaloMin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_MhaloMin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_MhaloMin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MhaloMin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MhaloMin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MhaloMin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_MhaloMin" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  result = (double)((cosmobl::Cosmology const *)arg1)->MhaloMin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MhaloMin__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  std::string arg12 ;
  std::string arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MhaloMin" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MhaloMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MhaloMin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_MhaloMin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_MhaloMin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_MhaloMin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MhaloMin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MhaloMin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MhaloMin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->MhaloMin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MhaloMin__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  std::string arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MhaloMin" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MhaloMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MhaloMin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_MhaloMin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_MhaloMin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_MhaloMin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MhaloMin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MhaloMin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MhaloMin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->MhaloMin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MhaloMin__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MhaloMin" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MhaloMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MhaloMin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_MhaloMin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_MhaloMin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_MhaloMin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MhaloMin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MhaloMin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MhaloMin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MhaloMin" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->MhaloMin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MhaloMin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[18] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 17) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_MhaloMin__SWIG_6(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_Cosmology_MhaloMin__SWIG_5(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_Cosmology_MhaloMin__SWIG_4(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_MhaloMin__SWIG_3(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_MhaloMin__SWIG_2(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_MhaloMin__SWIG_1(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    int res = SWIG_AsPtr_std_string(argv[16], (std::string**)(0));
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_Cosmology_MhaloMin__SWIG_0(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_MhaloMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::MhaloMin(int const,double const,bool const,double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,int const,double const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::MhaloMin(int const,double const,bool const,double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,int const,double const,double const) const\n"
    "    cosmobl::Cosmology::MhaloMin(int const,double const,bool const,double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,int const,double const) const\n"
    "    cosmobl::Cosmology::MhaloMin(int const,double const,bool const,double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,int const) const\n"
    "    cosmobl::Cosmology::MhaloMin(int const,double const,bool const,double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::MhaloMin(int const,double const,bool const,double const,double const,double const,double const,double const,std::string const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::MhaloMin(int const,double const,bool const,double const,double const,double const,double const,double const,std::string const,std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_pw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_pw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_pw" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_pw" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_pw" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_pw" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->pw(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_pz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_pz",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_pz" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_pz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_pz" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_pz" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_pz" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_pz" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_pz" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_pz" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->pz(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_pz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_pz",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_pz" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_pz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_pz" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_pz" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_pz" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_pz" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_pz" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->pz(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_pz(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_pz__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_pz__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_pz'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::pz(double const,double const,double const,double const,std::string const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::pz(double const,double const,double const,double const,std::string const,std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_cumPw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_cumPw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_cumPw" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_cumPw" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_cumPw" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_cumPw" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->cumPw(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_medianwf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::vector< double > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_medianwf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_medianwf" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_medianwf" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_medianwf" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_medianwf" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_medianwf" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ((cosmobl::Cosmology const *)arg1)->medianwf(arg2,arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_medianzf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::vector< double > *arg7 = 0 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_medianzf",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_medianzf" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_medianzf" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_medianzf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_medianzf" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_medianzf" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_medianzf" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_medianzf" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_medianzf" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_medianzf" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Cosmology const *)arg1)->medianzf(arg2,arg3,arg4,arg5,arg6,*arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_medianzf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::vector< double > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_medianzf",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_medianzf" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_medianzf" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_medianzf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_medianzf" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_medianzf" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_medianzf" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_medianzf" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_medianzf" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  ((cosmobl::Cosmology const *)arg1)->medianzf(arg2,arg3,arg4,arg5,arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_medianzf(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_medianzf__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_medianzf__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_medianzf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::medianzf(double const,double const,double const,std::string const,std::string const,std::vector< double > &,std::string const) const\n"
    "    cosmobl::Cosmology::medianzf(double const,double const,double const,std::string const,std::string const,std::vector< double > &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_wf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_wf",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wf" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wf" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_wf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wf" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_wf" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wf" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wf" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->wf(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_wf",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wf" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wf" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_wf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wf" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_wf" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wf" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->wf(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wf(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_wf__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_wf__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_wf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::wf(double const,double const,double const,double const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::wf(double const,double const,double const,double const,std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_unevolved_mass_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_unevolved_mass_function",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_unevolved_mass_function" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_unevolved_mass_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->unevolved_mass_function(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_concentration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_concentration",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_concentration" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_concentration" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_concentration" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->concentration(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_As(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_As",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_As" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_As" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->As(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_UnNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Pk_UnNorm",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk_UnNorm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk_UnNorm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Pk_UnNorm" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_UnNorm" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Pk_UnNorm(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_run_CAMB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  bool arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_run_CAMB",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_run_CAMB" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_run_CAMB" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_run_CAMB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_run_CAMB" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_run_CAMB" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_run_CAMB" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Cosmology const *)arg1)->run_CAMB(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_run_CAMB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  bool arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_run_CAMB",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_run_CAMB" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_run_CAMB" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_run_CAMB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_run_CAMB" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_run_CAMB" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ((cosmobl::Cosmology const *)arg1)->run_CAMB(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_run_CAMB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  bool arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_run_CAMB",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_run_CAMB" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_run_CAMB" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_run_CAMB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_run_CAMB" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Cosmology const *)arg1)->run_CAMB(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_run_CAMB__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  bool arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_run_CAMB",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_run_CAMB" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_run_CAMB" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_run_CAMB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ((cosmobl::Cosmology const *)arg1)->run_CAMB(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_run_CAMB(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_run_CAMB__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_run_CAMB__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_run_CAMB__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_run_CAMB__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_run_CAMB'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::run_CAMB(bool const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::run_CAMB(bool const,double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::run_CAMB(bool const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::run_CAMB(bool const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_Table_PkCodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_Table_PkCodes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Table_PkCodes" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Table_PkCodes" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Table_PkCodes" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_Table_PkCodes" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_Table_PkCodes" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_Table_PkCodes" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_Table_PkCodes" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Table_PkCodes" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Table_PkCodes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Table_PkCodes" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Table_PkCodes" "', argument " "9"" of type '" "std::string""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Cosmology const *)arg1)->Table_PkCodes(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Table_PkCodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_Table_PkCodes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Table_PkCodes" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Table_PkCodes" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Table_PkCodes" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_Table_PkCodes" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_Table_PkCodes" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_Table_PkCodes" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_Table_PkCodes" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Table_PkCodes" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Table_PkCodes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Table_PkCodes" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ((cosmobl::Cosmology const *)arg1)->Table_PkCodes(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Table_PkCodes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  double arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_Table_PkCodes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Table_PkCodes" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Table_PkCodes" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Table_PkCodes" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_Table_PkCodes" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_Table_PkCodes" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_Table_PkCodes" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_Table_PkCodes" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Table_PkCodes" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Table_PkCodes" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Cosmology const *)arg1)->Table_PkCodes(arg2,arg3,*arg4,*arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Table_PkCodes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_Table_PkCodes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Table_PkCodes" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Table_PkCodes" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Table_PkCodes" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_Table_PkCodes" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_Table_PkCodes" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_Table_PkCodes" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_Table_PkCodes" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Table_PkCodes" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ((cosmobl::Cosmology const *)arg1)->Table_PkCodes(arg2,arg3,*arg4,*arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Table_PkCodes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_Table_PkCodes__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_Table_PkCodes__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_Table_PkCodes__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Cosmology_Table_PkCodes__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Table_PkCodes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Table_PkCodes(std::string const,bool const,std::vector< double > &,std::vector< double > &,double const,std::string const,double const,std::string) const\n"
    "    cosmobl::Cosmology::Table_PkCodes(std::string const,bool const,std::vector< double > &,std::vector< double > &,double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::Table_PkCodes(std::string const,bool const,std::vector< double > &,std::vector< double > &,double const,std::string const) const\n"
    "    cosmobl::Cosmology::Table_PkCodes(std::string const,bool const,std::vector< double > &,std::vector< double > &,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_0__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  std::string arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_Pk_0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk_0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Pk_0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk_0" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Pk_0" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk_0" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Pk_0" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->Pk_0(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_0__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_Pk_0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk_0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Pk_0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk_0" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Pk_0" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk_0" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Pk_0" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  (arg1)->Pk_0(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_0__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_Pk_0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk_0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Pk_0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk_0" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Pk_0" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk_0" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->Pk_0(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_0__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_Pk_0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk_0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Pk_0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk_0" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Pk_0" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  (arg1)->Pk_0(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_0__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_Pk_0",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk_0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Pk_0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk_0" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->Pk_0(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_0__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Pk_0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk_0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Pk_0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->Pk_0(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_0__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_Pk_0",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk_0" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk_0" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Pk_0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->Pk_0(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk_0(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_Pk_0__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_Pk_0__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_Pk_0__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_Pk_0__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_Pk_0__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_Pk_0__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Cosmology_Pk_0__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Pk_0'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Pk_0(std::string const,double const,std::string const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::Pk_0(std::string const,double const,std::string const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::Pk_0(std::string const,double const,std::string const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::Pk_0(std::string const,double const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::Pk_0(std::string const,double const,std::string const,double const)\n"
    "    cosmobl::Cosmology::Pk_0(std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::Pk_0(std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  bool arg4 ;
  double arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  bool arg10 ;
  double arg11 ;
  std::string arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Pk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Pk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_Pk" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_Pk" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_Pk" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->Pk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  bool arg4 ;
  double arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  bool arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Pk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Pk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_Pk" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_Pk" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_Pk" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->Pk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  bool arg4 ;
  double arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Pk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Pk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_Pk" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_Pk" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  result = (double)(arg1)->Pk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  bool arg4 ;
  double arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Pk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Pk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_Pk" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->Pk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  bool arg4 ;
  double arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Pk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Pk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->Pk(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  bool arg4 ;
  double arg5 ;
  std::string arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Pk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Pk" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)(arg1)->Pk(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  bool arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Pk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->Pk(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  bool arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_Pk",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Pk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Pk" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Pk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Pk" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->Pk(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Pk(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[13] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 12) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_Pk__SWIG_7(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_Pk__SWIG_6(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_Pk__SWIG_5(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_Pk__SWIG_4(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_Pk__SWIG_3(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_Pk__SWIG_2(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_Pk__SWIG_1(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_Cosmology_Pk__SWIG_0(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Pk'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Pk(double const,std::string const,bool const,double const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::Pk(double const,std::string const,bool const,double const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::Pk(double const,std::string const,bool const,double const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::Pk(double const,std::string const,bool const,double const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::Pk(double const,std::string const,bool const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::Pk(double const,std::string const,bool const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::Pk(double const,std::string const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::Pk(double const,std::string const,bool const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_SSR",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSR" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_SSR" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->SSR(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_SSR",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSR" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_SSR" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->SSR(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_SSR",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSR" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->SSR(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_SSR",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSR" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->SSR(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_SSR__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_SSR__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_SSR__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_SSR__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_SSR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::SSR(double const,std::string const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::SSR(double const,std::string const,double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::SSR(double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::SSR(double const,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR_norm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_SSR_norm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSR_norm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSR_norm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR_norm" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSR_norm" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR_norm" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_SSR_norm" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR_norm" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->SSR_norm(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR_norm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_SSR_norm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSR_norm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSR_norm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR_norm" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSR_norm" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR_norm" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_SSR_norm" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->SSR_norm(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR_norm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_SSR_norm",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSR_norm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSR_norm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR_norm" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSR_norm" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR_norm" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->SSR_norm(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR_norm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_SSR_norm",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSR_norm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSR_norm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSR_norm" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSR_norm" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->SSR_norm(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSR_norm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_SSR_norm__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_SSR_norm__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_SSR_norm__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_SSR_norm__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_SSR_norm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::SSR_norm(double const,std::string const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::SSR_norm(double const,std::string const,double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::SSR_norm(double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::SSR_norm(double const,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_SSM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_SSM" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->SSM(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_SSM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_SSM" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->SSM(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_SSM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->SSM(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_SSM",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->SSM(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_SSM__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_SSM__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_SSM__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_SSM__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_SSM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::SSM(double const,std::string const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::SSM(double const,std::string const,double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::SSM(double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::SSM(double const,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM_norm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_SSM_norm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSM_norm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSM_norm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM_norm" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSM_norm" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM_norm" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_SSM_norm" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM_norm" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->SSM_norm(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM_norm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_SSM_norm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSM_norm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSM_norm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM_norm" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSM_norm" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM_norm" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_SSM_norm" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->SSM_norm(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM_norm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_SSM_norm",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSM_norm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSM_norm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM_norm" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSM_norm" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM_norm" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->SSM_norm(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM_norm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_SSM_norm",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_SSM_norm" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_SSM_norm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_SSM_norm" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_SSM_norm" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->SSM_norm(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_SSM_norm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_SSM_norm__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_SSM_norm__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_SSM_norm__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_SSM_norm__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_SSM_norm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::SSM_norm(double const,std::string const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::SSM_norm(double const,std::string const,double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::SSM_norm(double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::SSM_norm(double const,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_dnSR",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSR" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dnSR" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_dnSR" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_dnSR" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSR(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_dnSR",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSR" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dnSR" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_dnSR" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_dnSR" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSR(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSR__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  int arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_dnSR",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSR" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dnSR" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_dnSR" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSR(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSR__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_dnSR",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSR" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dnSR" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSR(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSR__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_dnSR",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSR" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSR(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSR__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_dnSR",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSR" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSR(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSR__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_dnSR",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSR" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSR" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSR" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSR(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSR(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_dnSR__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_dnSR__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_dnSR__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_dnSR__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_dnSR__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_dnSR__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_dnSR__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_dnSR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::dnSR(int const,double const,std::string const,double const,std::string const,std::string const,int const,double const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::dnSR(int const,double const,std::string const,double const,std::string const,std::string const,int const,double const,double const) const\n"
    "    cosmobl::Cosmology::dnSR(int const,double const,std::string const,double const,std::string const,std::string const,int const,double const) const\n"
    "    cosmobl::Cosmology::dnSR(int const,double const,std::string const,double const,std::string const,std::string const,int const) const\n"
    "    cosmobl::Cosmology::dnSR(int const,double const,std::string const,double const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::dnSR(int const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::dnSR(int const,double const,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_dnSM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSM" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dnSM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_dnSM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_dnSM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_dnSM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSM" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dnSM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_dnSM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_dnSM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  int arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_dnSM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSM" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dnSM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_dnSM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_dnSM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSM" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dnSM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSM(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSM__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_dnSM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSM" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSM(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSM__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_dnSM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSM" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSM(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSM__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_dnSM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dnSM" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dnSM" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_dnSM" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dnSM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dnSM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->dnSM(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dnSM(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_dnSM__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_dnSM__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_dnSM__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_dnSM__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_dnSM__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_dnSM__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_dnSM__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_dnSM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::dnSM(int const,double const,std::string const,double const,std::string const,std::string const,int const,double const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::dnSM(int const,double const,std::string const,double const,std::string const,std::string const,int const,double const,double const) const\n"
    "    cosmobl::Cosmology::dnSM(int const,double const,std::string const,double const,std::string const,std::string const,int const,double const) const\n"
    "    cosmobl::Cosmology::dnSM(int const,double const,std::string const,double const,std::string const,std::string const,int const) const\n"
    "    cosmobl::Cosmology::dnSM(int const,double const,std::string const,double const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::dnSM(int const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::dnSM(int const,double const,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  bool arg11 ;
  double arg12 ;
  std::string arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi_DM" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi_DM" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  bool arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi_DM" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi_DM" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi_DM" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  int arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_xi_DM",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xi_DM(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[14] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 13) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_xi_DM__SWIG_9(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_xi_DM__SWIG_8(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_xi_DM__SWIG_7(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_xi_DM__SWIG_6(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_xi_DM__SWIG_5(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_xi_DM__SWIG_4(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_xi_DM__SWIG_3(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_xi_DM__SWIG_2(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_xi_DM__SWIG_1(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_Cosmology_xi_DM__SWIG_0(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_xi_DM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const,bool const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const,bool const,int const,double const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const,bool const,int const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const,bool const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi_DM(double const,std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM_DeWiggle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_xi_DM_DeWiggle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->xi_DM_DeWiggle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM_DeWiggle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_xi_DM_DeWiggle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->xi_DM_DeWiggle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM_DeWiggle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_xi_DM_DeWiggle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->xi_DM_DeWiggle(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM_DeWiggle__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_xi_DM_DeWiggle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->xi_DM_DeWiggle(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM_DeWiggle__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_xi_DM_DeWiggle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (double)(arg1)->xi_DM_DeWiggle(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM_DeWiggle__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_xi_DM_DeWiggle",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi_DM_DeWiggle(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM_DeWiggle__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_xi_DM_DeWiggle",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi_DM_DeWiggle" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xi_DM_DeWiggle(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_DM_DeWiggle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_xi_DM_DeWiggle__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_xi_DM_DeWiggle__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_xi_DM_DeWiggle__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_xi_DM_DeWiggle__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_xi_DM_DeWiggle__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_xi_DM_DeWiggle__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_xi_DM_DeWiggle__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_xi_DM_DeWiggle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::xi_DM_DeWiggle(double const,double const,double const,std::string const,bool const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi_DM_DeWiggle(double const,double const,double const,std::string const,bool const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi_DM_DeWiggle(double const,double const,double const,std::string const,bool const,double const,double const)\n"
    "    cosmobl::Cosmology::xi_DM_DeWiggle(double const,double const,double const,std::string const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi_DM_DeWiggle(double const,double const,double const,std::string const,bool const)\n"
    "    cosmobl::Cosmology::xi_DM_DeWiggle(double const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi_DM_DeWiggle(double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  double arg17 ;
  std::string arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_xi" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_get_xi" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_get_xi" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj17, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "18"" of type '" "std::string const""'"); 
    }
    arg18 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_xi" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_get_xi" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_get_xi" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_xi" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_get_xi" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_xi" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_xi" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_xi" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_xi" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_xi" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_xi" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_get_xi",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_xi" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_xi" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_xi" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_get_xi" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->get_xi(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_xi(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[19] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 18) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_get_xi__SWIG_13(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_get_xi__SWIG_12(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_get_xi__SWIG_11(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_get_xi__SWIG_10(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_get_xi__SWIG_9(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_get_xi__SWIG_8(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_get_xi__SWIG_7(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_get_xi__SWIG_6(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_get_xi__SWIG_5(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_get_xi__SWIG_4(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_get_xi__SWIG_3(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_get_xi__SWIG_2(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_get_xi__SWIG_1(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_AsPtr_std_string(argv[17], (std::string**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_Cosmology_get_xi__SWIG_0(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_get_xi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const,int const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const,bool const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const,double const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const,bool const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::get_xi(std::vector< double > &,std::vector< double > &,std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  std::string arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_barred_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_barred_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_barred_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_barred_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_get_barred_xi" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_get_barred_xi" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_get_barred_xi" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj18, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "19"" of type '" "std::string const""'"); 
    }
    arg19 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_barred_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_barred_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_barred_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_barred_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_get_barred_xi" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_get_barred_xi" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_get_barred_xi" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_barred_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_barred_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_barred_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_barred_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_get_barred_xi" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_get_barred_xi" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_barred_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_barred_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_barred_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_barred_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_get_barred_xi" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_barred_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_barred_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_barred_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_get_barred_xi" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_barred_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_barred_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_get_barred_xi" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_barred_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_get_barred_xi" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_get_barred_xi" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_get_barred_xi" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_get_barred_xi" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_get_barred_xi" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_get_barred_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_get_barred_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_get_barred_xi" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_get_barred_xi" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_get_barred_xi" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_get_barred_xi" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ((cosmobl::Cosmology const *)arg1)->get_barred_xi(arg2,arg3,*arg4,*arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_get_barred_xi(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[20] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 19) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_get_barred_xi__SWIG_12(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_get_barred_xi__SWIG_11(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_get_barred_xi__SWIG_10(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_get_barred_xi__SWIG_9(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_get_barred_xi__SWIG_8(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_get_barred_xi__SWIG_7(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_get_barred_xi__SWIG_6(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_get_barred_xi__SWIG_5(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_get_barred_xi__SWIG_4(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_get_barred_xi__SWIG_3(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_get_barred_xi__SWIG_2(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_get_barred_xi__SWIG_1(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        int res = SWIG_AsPtr_std_string(argv[18], (std::string**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_Cosmology_get_barred_xi__SWIG_0(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_get_barred_xi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const,double const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const,double const,double const,double const,double const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const,double const,double const,double const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const,double const,double const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const,double const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const,int const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const,bool const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const,double const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,bool const) const\n"
    "    cosmobl::Cosmology::get_barred_xi(std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  std::string arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_wp_DM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_wp_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_wp_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_wp_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_wp_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_wp_DM" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_wp_DM" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj13, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "14"" of type '" "std::string const""'"); 
    }
    arg14 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_wp_DM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_wp_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_wp_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_wp_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_wp_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_wp_DM" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_wp_DM" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_wp_DM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_wp_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_wp_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_wp_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_wp_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_wp_DM" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_wp_DM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_wp_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_wp_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_wp_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_wp_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_wp_DM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_wp_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_wp_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_wp_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_wp_DM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_wp_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_wp_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_wp_DM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_wp_DM" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_wp_DM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_wp_DM" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_wp_DM",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_wp_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_wp_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_wp_DM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_wp_DM" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->wp_DM(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_wp_DM(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[15] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 14) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_wp_DM__SWIG_10(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_wp_DM__SWIG_9(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_wp_DM__SWIG_8(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_wp_DM__SWIG_7(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_wp_DM__SWIG_6(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_wp_DM__SWIG_5(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_wp_DM__SWIG_4(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_wp_DM__SWIG_3(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_wp_DM__SWIG_2(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_wp_DM__SWIG_1(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_AsPtr_std_string(argv[13], (std::string**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_Cosmology_wp_DM__SWIG_0(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_wp_DM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const,double const,double const,double const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const,double const,double const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const,double const,double const,double const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::wp_DM(double const,std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_k_star__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_k_star",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_k_star" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_k_star" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_k_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_k_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_k_star" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_k_star" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->k_star(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_k_star__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_k_star",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_k_star" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_k_star" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_k_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_k_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_k_star" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->k_star(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_k_star__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_k_star",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_k_star" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_k_star" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_k_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_k_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->k_star(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_k_star__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_k_star",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_k_star" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_k_star" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_k_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->k_star(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_k_star(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_k_star__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_k_star__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_k_star__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_k_star__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_k_star'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::k_star(std::string const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::k_star(std::string const,double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::k_star(std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::k_star(std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  std::string arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigmaR_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_sigmaR_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_sigmaR_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_sigmaR_DM" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_sigmaR_DM" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_sigmaR_DM" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_sigmaR_DM" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj15, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "16"" of type '" "std::string const""'"); 
    }
    arg16 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigmaR_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_sigmaR_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_sigmaR_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_sigmaR_DM" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_sigmaR_DM" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_sigmaR_DM" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_sigmaR_DM" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigmaR_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_sigmaR_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_sigmaR_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_sigmaR_DM" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_sigmaR_DM" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_sigmaR_DM" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigmaR_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_sigmaR_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_sigmaR_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_sigmaR_DM" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_sigmaR_DM" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigmaR_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_sigmaR_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_sigmaR_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_sigmaR_DM" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigmaR_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_sigmaR_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_sigmaR_DM" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigmaR_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_sigmaR_DM" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigmaR_DM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigmaR_DM" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigmaR_DM" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_sigmaR_DM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigmaR_DM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_sigmaR_DM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigmaR_DM" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigmaR_DM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigmaR_DM" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->sigmaR_DM(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigmaR_DM(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[17] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 16) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_sigmaR_DM__SWIG_11(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_sigmaR_DM__SWIG_10(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_sigmaR_DM__SWIG_9(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_sigmaR_DM__SWIG_8(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_sigmaR_DM__SWIG_7(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_sigmaR_DM__SWIG_6(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_sigmaR_DM__SWIG_5(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_sigmaR_DM__SWIG_4(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_sigmaR_DM__SWIG_3(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_sigmaR_DM__SWIG_2(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_sigmaR_DM__SWIG_1(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_AsPtr_std_string(argv[15], (std::string**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_Cosmology_sigmaR_DM__SWIG_0(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_sigmaR_DM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const,double const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const,int const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const,bool const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::sigmaR_DM(double const,int const,std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  bool arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_sigma8_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigma8_Pk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigma8_Pk" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_sigma8_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigma8_Pk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigma8_Pk" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigma8_Pk" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8_Pk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  bool arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_sigma8_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigma8_Pk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigma8_Pk" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_sigma8_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigma8_Pk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigma8_Pk" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_sigma8_Pk" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8_Pk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  bool arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_sigma8_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigma8_Pk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigma8_Pk" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_sigma8_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigma8_Pk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_sigma8_Pk" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8_Pk(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  bool arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_sigma8_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigma8_Pk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigma8_Pk" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_sigma8_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_sigma8_Pk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8_Pk(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  bool arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_sigma8_Pk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigma8_Pk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigma8_Pk" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_sigma8_Pk" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8_Pk(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_sigma8_Pk",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigma8_Pk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_sigma8_Pk" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8_Pk(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_sigma8_Pk",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigma8_Pk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8_Pk(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_sigma8_Pk",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_sigma8_Pk" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_sigma8_Pk" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_sigma8_Pk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->sigma8_Pk(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_sigma8_Pk(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_sigma8_Pk__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_sigma8_Pk__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_sigma8_Pk__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_sigma8_Pk__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_sigma8_Pk__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_sigma8_Pk__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_sigma8_Pk__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_sigma8_Pk__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_sigma8_Pk'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::sigma8_Pk(std::string const,double const,std::string const,bool const,double const,double const,bool const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::sigma8_Pk(std::string const,double const,std::string const,bool const,double const,double const,bool const,double const) const\n"
    "    cosmobl::Cosmology::sigma8_Pk(std::string const,double const,std::string const,bool const,double const,double const,bool const) const\n"
    "    cosmobl::Cosmology::sigma8_Pk(std::string const,double const,std::string const,bool const,double const,double const) const\n"
    "    cosmobl::Cosmology::sigma8_Pk(std::string const,double const,std::string const,bool const,double const) const\n"
    "    cosmobl::Cosmology::sigma8_Pk(std::string const,double const,std::string const,bool const) const\n"
    "    cosmobl::Cosmology::sigma8_Pk(std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::sigma8_Pk(std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  std::string arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_halo" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_halo" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj13, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "14"" of type '" "std::string const""'"); 
    }
    arg14 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_halo" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_halo" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_halo" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  std::string arg14 ;
  std::string arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_halo" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_halo" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj13, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "14"" of type '" "std::string const""'"); 
    }
    arg14 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  std::string arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_halo" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_halo" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj13, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "14"" of type '" "std::string const""'"); 
    }
    arg14 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_halo" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_halo" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_halo" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_halo" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_halo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_halo" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_bias_halo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_halo" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_halo" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_halo(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_halo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[16] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 15) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_bias_halo__SWIG_20(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_bias_halo__SWIG_9(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_bias_halo__SWIG_19(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_bias_halo__SWIG_8(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_bias_halo__SWIG_18(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_bias_halo__SWIG_7(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_bias_halo__SWIG_17(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_bias_halo__SWIG_6(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_bias_halo__SWIG_16(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_bias_halo__SWIG_5(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_bias_halo__SWIG_15(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_bias_halo__SWIG_4(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_bias_halo__SWIG_14(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_bias_halo__SWIG_3(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_bias_halo__SWIG_13(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_bias_halo__SWIG_2(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_bias_halo__SWIG_12(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_bias_halo__SWIG_1(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_AsPtr_std_string(argv[13], (std::string**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_Cosmology_bias_halo__SWIG_11(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_AsPtr_std_string(argv[13], (std::string**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_Cosmology_bias_halo__SWIG_0(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_AsPtr_std_string(argv[13], (std::string**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_Cosmology_bias_halo__SWIG_10(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_bias_halo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const,double const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const,double const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const,double const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const,double const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const,double const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const,double const,double const,int const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const,double const,int const,double const,double const,bool const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const,double const,int const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bias_halo(double const,double const,double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  std::string arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_bias_eff" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_bias_eff" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_bias_eff" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj18, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "19"" of type '" "std::string const""'"); 
    }
    arg19 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_bias_eff" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_bias_eff" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_bias_eff" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_bias_eff" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_bias_eff" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_bias_eff" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  double arg17 ;
  std::string arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_bias_eff" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_bias_eff" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj17, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "18"" of type '" "std::string const""'"); 
    }
    arg18 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_bias_eff" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_bias_eff" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_bias_eff" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_bias_eff" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_bias_eff" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_bias_eff" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_bias_eff" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_bias_eff" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_22(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_eff" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_23(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_eff" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_24(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff__SWIG_25(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_bias_eff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_eff" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bias_eff" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_bias_eff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_eff" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_eff(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_eff(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[20] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 19) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_bias_eff__SWIG_25(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_bias_eff__SWIG_24(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_bias_eff__SWIG_12(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_bias_eff__SWIG_23(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_bias_eff__SWIG_11(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_bias_eff__SWIG_22(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_bias_eff__SWIG_10(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_bias_eff__SWIG_21(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_bias_eff__SWIG_9(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_bias_eff__SWIG_20(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_bias_eff__SWIG_8(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_bias_eff__SWIG_19(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_bias_eff__SWIG_7(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_bias_eff__SWIG_18(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_bias_eff__SWIG_6(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_bias_eff__SWIG_17(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_bias_eff__SWIG_5(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_bias_eff__SWIG_16(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_bias_eff__SWIG_4(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_bias_eff__SWIG_15(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_bias_eff__SWIG_3(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_bias_eff__SWIG_14(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_bias_eff__SWIG_2(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_AsPtr_std_string(argv[17], (std::string**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_Cosmology_bias_eff__SWIG_13(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_bias_eff__SWIG_1(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        int res = SWIG_AsPtr_std_string(argv[18], (std::string**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_Cosmology_bias_eff__SWIG_0(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_bias_eff'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bias_eff(double const,double const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bias_eff(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_linear_growth_rate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_linear_growth_rate",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_linear_growth_rate" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_linear_growth_rate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_linear_growth_rate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->linear_growth_rate(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_linear_growth_rate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_linear_growth_rate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_linear_growth_rate" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_linear_growth_rate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->linear_growth_rate(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_linear_growth_rate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Cosmology_linear_growth_rate__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_linear_growth_rate__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_linear_growth_rate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::linear_growth_rate(double const,double const) const\n"
    "    cosmobl::Cosmology::linear_growth_rate(double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  double arg5 ;
  bool arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_fsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_fsigma8" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_fsigma8" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_fsigma8" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_fsigma8" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_fsigma8" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_fsigma8" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  double arg5 ;
  bool arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_fsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_fsigma8" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_fsigma8" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_fsigma8" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_fsigma8" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_fsigma8" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_fsigma8" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  double arg5 ;
  bool arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_fsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_fsigma8" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_fsigma8" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_fsigma8" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_fsigma8" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_fsigma8" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  double arg5 ;
  bool arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_fsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_fsigma8" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_fsigma8" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_fsigma8" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_fsigma8" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  double arg5 ;
  bool arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_fsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_fsigma8" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_fsigma8" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_fsigma8" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  double arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_fsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_fsigma8" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_fsigma8" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_fsigma8",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_fsigma8" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_fsigma8",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_fsigma8",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_fsigma8" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_fsigma8" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_fsigma8" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->fsigma8(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_fsigma8(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Cosmology_fsigma8__SWIG_8(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_fsigma8__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_fsigma8__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_fsigma8__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_fsigma8__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_fsigma8__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_fsigma8__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_fsigma8__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_fsigma8__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_fsigma8'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const,std::string const,double const,bool const,double const,double const,bool const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const,std::string const,double const,bool const,double const,double const,bool const,double const) const\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const,std::string const,double const,bool const,double const,double const,bool const) const\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const,std::string const,double const,bool const,double const,double const) const\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const,std::string const,double const,bool const,double const) const\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const,std::string const,double const,bool const) const\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::fsigma8(double const,std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->beta(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_beta",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->beta(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->error_beta(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->error_beta(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  std::string arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_beta" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_beta" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj18, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "19"" of type '" "std::string const""'"); 
    }
    arg19 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_beta" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_beta" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_beta" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  int arg13 ;
  double arg14 ;
  int arg15 ;
  double arg16 ;
  double arg17 ;
  bool arg18 ;
  double arg19 ;
  std::string arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_error_beta" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  int arg13 ;
  double arg14 ;
  int arg15 ;
  double arg16 ;
  double arg17 ;
  bool arg18 ;
  double arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_error_beta" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  int arg13 ;
  double arg14 ;
  int arg15 ;
  double arg16 ;
  double arg17 ;
  bool arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  int arg13 ;
  double arg14 ;
  int arg15 ;
  double arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  int arg13 ;
  double arg14 ;
  int arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  int arg13 ;
  double arg14 ;
  int arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  int arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  int arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  std::string arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  std::string arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  double arg17 ;
  std::string arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_beta" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_beta" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj17, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "18"" of type '" "std::string const""'"); 
    }
    arg18 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_beta" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_beta" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_beta" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_beta" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_beta" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_beta" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_22(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_beta" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_23(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_24(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_25(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_beta" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_26(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta__SWIG_27(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->beta(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_beta(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[20] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 19) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_beta__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_beta__SWIG_0(self, args);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_beta__SWIG_27(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_beta__SWIG_26(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_beta__SWIG_14(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_beta__SWIG_25(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_beta__SWIG_13(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_beta__SWIG_24(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_beta__SWIG_12(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_beta__SWIG_23(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_beta__SWIG_11(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_beta__SWIG_22(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_beta__SWIG_10(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_beta__SWIG_21(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_beta__SWIG_9(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_beta__SWIG_20(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_beta__SWIG_8(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_beta__SWIG_19(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_beta__SWIG_7(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_beta__SWIG_18(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_beta__SWIG_6(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_beta__SWIG_17(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_beta__SWIG_5(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_beta__SWIG_16(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_beta__SWIG_4(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_AsPtr_std_string(argv[17], (std::string**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_Cosmology_beta__SWIG_15(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_beta__SWIG_3(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        int res = SWIG_AsPtr_std_string(argv[18], (std::string**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_Cosmology_beta__SWIG_2(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_beta'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const) const\n"
    "    cosmobl::Cosmology::beta(double const,double const) const\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::beta(double const,double const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  std::string arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj18, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "19"" of type '" "std::string const""'"); 
    }
    arg19 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_error_beta" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_22(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_23(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_24(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_error_beta" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_25(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_error_beta" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_26(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta__SWIG_27(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_error_beta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_error_beta" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_error_beta" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->error_beta(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[21] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 20) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_error_beta__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_error_beta__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_error_beta__SWIG_27(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_error_beta__SWIG_26(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_error_beta__SWIG_14(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_error_beta__SWIG_25(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Cosmology_error_beta__SWIG_13(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_error_beta__SWIG_24(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_error_beta__SWIG_12(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_error_beta__SWIG_23(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_error_beta__SWIG_11(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_error_beta__SWIG_22(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_Cosmology_error_beta__SWIG_10(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_error_beta__SWIG_21(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_error_beta__SWIG_9(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_error_beta__SWIG_20(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_error_beta__SWIG_8(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_error_beta__SWIG_19(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_error_beta__SWIG_7(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_error_beta__SWIG_18(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_error_beta__SWIG_6(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_error_beta__SWIG_17(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_error_beta__SWIG_5(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_error_beta__SWIG_16(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_error_beta__SWIG_4(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        int res = SWIG_AsPtr_std_string(argv[18], (std::string**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_Cosmology_error_beta__SWIG_15(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_Cosmology_error_beta__SWIG_3(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_Cosmology_error_beta__SWIG_2(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_error_beta'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,double const) const\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const) const\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const,double const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta(double const,double const,double const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const,double const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  int arg16 ;
  double arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  std::string arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta_measured" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta_measured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta_measured" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta_measured" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta_measured" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_error_beta_measured" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_error_beta_measured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj20, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "21"" of type '" "std::string const""'"); 
    }
    arg21 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  int arg16 ;
  double arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta_measured" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta_measured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta_measured" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta_measured" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta_measured" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_error_beta_measured" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_error_beta_measured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  int arg16 ;
  double arg17 ;
  double arg18 ;
  bool arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta_measured" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta_measured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta_measured" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta_measured" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta_measured" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_error_beta_measured" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  int arg16 ;
  double arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta_measured" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta_measured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta_measured" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta_measured" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_error_beta_measured" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  int arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta_measured" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta_measured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta_measured" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_error_beta_measured" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  int arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta_measured" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta_measured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_error_beta_measured" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  int arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta_measured" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_error_beta_measured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  int arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_error_beta_measured" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_error_beta_measured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_error_beta_measured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_error_beta_measured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_error_beta_measured" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_error_beta_measured" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_error_beta_measured" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_error_beta_measured" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_error_beta_measured" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_error_beta_measured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_error_beta_measured" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->error_beta_measured(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_error_beta_measured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[22] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 21) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Cosmology_error_beta_measured__SWIG_12(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_error_beta_measured__SWIG_11(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_error_beta_measured__SWIG_10(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_error_beta_measured__SWIG_9(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_Cosmology_error_beta_measured__SWIG_8(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_error_beta_measured__SWIG_7(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_error_beta_measured__SWIG_6(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_error_beta_measured__SWIG_5(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_error_beta_measured__SWIG_4(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_error_beta_measured__SWIG_3(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_Cosmology_error_beta_measured__SWIG_2(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_Cosmology_error_beta_measured__SWIG_1(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            int res = SWIG_AsPtr_std_string(argv[20], (std::string**)(0));
                                            _v = SWIG_CheckState(res);
                                            if (_v) {
                                              return _wrap_Cosmology_error_beta_measured__SWIG_0(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_error_beta_measured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::error_beta_measured(double const,double const,double const,double const,double const,std::string const,std::string const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  std::string arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_quadrupole" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_quadrupole" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_quadrupole" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj18, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "19"" of type '" "std::string const""'"); 
    }
    arg19 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_quadrupole" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_quadrupole" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_quadrupole" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_quadrupole" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_quadrupole" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_quadrupole" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  int arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_int(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "int""'");
  } 
  arg14 = static_cast< int >(val14);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  int arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  double arg17 ;
  std::string arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_quadrupole" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_quadrupole" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj17, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "18"" of type '" "std::string const""'"); 
    }
    arg18 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_quadrupole" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_quadrupole" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_bool(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_quadrupole" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_quadrupole" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_quadrupole" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  int arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_quadrupole" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_quadrupole" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_quadrupole" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_22(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_quadrupole" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_23(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_quadrupole" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_24(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole__SWIG_25(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_quadrupole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_quadrupole" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_quadrupole" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_quadrupole" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_quadrupole" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->quadrupole(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_quadrupole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[20] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 19) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_quadrupole__SWIG_25(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_quadrupole__SWIG_24(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_quadrupole__SWIG_12(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_quadrupole__SWIG_23(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_quadrupole__SWIG_11(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_quadrupole__SWIG_22(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_quadrupole__SWIG_10(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_quadrupole__SWIG_21(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_quadrupole__SWIG_9(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_quadrupole__SWIG_20(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_quadrupole__SWIG_8(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_quadrupole__SWIG_19(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_quadrupole__SWIG_7(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_quadrupole__SWIG_18(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_quadrupole__SWIG_6(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_quadrupole__SWIG_17(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_quadrupole__SWIG_5(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_quadrupole__SWIG_16(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_quadrupole__SWIG_4(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_quadrupole__SWIG_15(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_quadrupole__SWIG_3(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_quadrupole__SWIG_14(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_quadrupole__SWIG_2(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_AsPtr_std_string(argv[17], (std::string**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_Cosmology_quadrupole__SWIG_13(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_quadrupole__SWIG_1(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        int res = SWIG_AsPtr_std_string(argv[18], (std::string**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_Cosmology_quadrupole__SWIG_0(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_quadrupole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::quadrupole(double const,double const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const,int const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const,double const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::quadrupole(std::vector< double > const,std::vector< double > const,double const,std::string const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_square_bulk_flow",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_bulk_flow" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_bulk_flow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_bulk_flow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_bulk_flow" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_bulk_flow" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_square_bulk_flow" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_square_bulk_flow" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_square_bulk_flow" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->square_bulk_flow(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_square_bulk_flow",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_bulk_flow" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_bulk_flow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_bulk_flow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_bulk_flow" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_bulk_flow" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_square_bulk_flow" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_square_bulk_flow" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_square_bulk_flow" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->square_bulk_flow(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_square_bulk_flow",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_bulk_flow" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_bulk_flow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_bulk_flow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_bulk_flow" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_bulk_flow" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_square_bulk_flow" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_square_bulk_flow" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (double)(arg1)->square_bulk_flow(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_square_bulk_flow",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_bulk_flow" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_bulk_flow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_bulk_flow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_bulk_flow" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_bulk_flow" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_square_bulk_flow" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->square_bulk_flow(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_square_bulk_flow",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_bulk_flow" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_bulk_flow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_bulk_flow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_bulk_flow" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_bulk_flow" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->square_bulk_flow(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_square_bulk_flow",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_bulk_flow" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_bulk_flow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_bulk_flow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_bulk_flow" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->square_bulk_flow(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_square_bulk_flow",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_bulk_flow" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_bulk_flow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_bulk_flow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_bulk_flow" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_bulk_flow" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->square_bulk_flow(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_square_bulk_flow__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_square_bulk_flow__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_square_bulk_flow__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_square_bulk_flow__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_square_bulk_flow__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_square_bulk_flow__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_square_bulk_flow__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_square_bulk_flow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::square_bulk_flow(double const,double const,std::string const,double const,std::string const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::square_bulk_flow(double const,double const,std::string const,double const,std::string const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::square_bulk_flow(double const,double const,std::string const,double const,std::string const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::square_bulk_flow(double const,double const,std::string const,double const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::square_bulk_flow(double const,double const,std::string const,double const,std::string const,double const)\n"
    "    cosmobl::Cosmology::square_bulk_flow(double const,double const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::square_bulk_flow(double const,double const,std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_bulk_flow_Table(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_square_bulk_flow_Table",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_bulk_flow_Table" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_bulk_flow_Table" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_bulk_flow_Table" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Cosmology_square_bulk_flow_Table" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_square_bulk_flow_Table" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Cosmology_square_bulk_flow_Table" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_square_bulk_flow_Table" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_square_bulk_flow_Table" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)((cosmobl::Cosmology const *)arg1)->square_bulk_flow_Table(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_velocity_dispersion__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_square_velocity_dispersion",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->square_velocity_dispersion(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_velocity_dispersion__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_square_velocity_dispersion",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->square_velocity_dispersion(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_velocity_dispersion__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_square_velocity_dispersion",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (double)(arg1)->square_velocity_dispersion(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_velocity_dispersion__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_square_velocity_dispersion",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->square_velocity_dispersion(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_velocity_dispersion__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_square_velocity_dispersion",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->square_velocity_dispersion(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_velocity_dispersion__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_square_velocity_dispersion",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->square_velocity_dispersion(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_velocity_dispersion__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_square_velocity_dispersion",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_square_velocity_dispersion" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->square_velocity_dispersion(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_square_velocity_dispersion(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_square_velocity_dispersion__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_square_velocity_dispersion__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_square_velocity_dispersion__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_square_velocity_dispersion__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_square_velocity_dispersion__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_square_velocity_dispersion__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_square_velocity_dispersion__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_square_velocity_dispersion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::square_velocity_dispersion(double const,double const,std::string const,double const,std::string const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::square_velocity_dispersion(double const,double const,std::string const,double const,std::string const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::square_velocity_dispersion(double const,double const,std::string const,double const,std::string const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::square_velocity_dispersion(double const,double const,std::string const,double const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::square_velocity_dispersion(double const,double const,std::string const,double const,std::string const,double const)\n"
    "    cosmobl::Cosmology::square_velocity_dispersion(double const,double const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::square_velocity_dispersion(double const,double const,std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_CMN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_CMN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_CMN" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_CMN" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_CMN" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_CMN" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_CMN" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_CMN" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_CMN" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_CMN" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->CMN(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_CMN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_CMN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_CMN" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_CMN" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_CMN" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_CMN" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_CMN" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_CMN" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_CMN" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)((cosmobl::Cosmology const *)arg1)->CMN(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_CMN__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_CMN",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_CMN" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_CMN" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_CMN" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_CMN" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_CMN" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_CMN" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->CMN(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_CMN__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_CMN",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_CMN" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_CMN" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_CMN" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_CMN" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_CMN" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)((cosmobl::Cosmology const *)arg1)->CMN(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_CMN(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_CMN__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_CMN__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_CMN__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Cosmology_CMN__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_CMN'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::CMN(double const,double const,std::string const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::CMN(double const,double const,std::string const,double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::CMN(double const,double const,std::string const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::CMN(double const,double const,std::string const,double const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sn_PT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_Sn_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sn_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sn_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sn_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Sn_PT" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Sn_PT" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_Sn_PT" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Sn_PT(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sn_PT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_Sn_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sn_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sn_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sn_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Sn_PT" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Sn_PT" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_Sn_PT" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)((cosmobl::Cosmology const *)arg1)->Sn_PT(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sn_PT__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_Sn_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sn_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sn_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sn_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Sn_PT" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Sn_PT" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)((cosmobl::Cosmology const *)arg1)->Sn_PT(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sn_PT__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_Sn_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sn_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sn_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sn_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Sn_PT" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)((cosmobl::Cosmology const *)arg1)->Sn_PT(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sn_PT__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_Sn_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sn_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sn_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sn_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Sn_PT(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sn_PT__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_Sn_PT",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sn_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sn_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sn_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Sn_PT(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sn_PT__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Sn_PT",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sn_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sn_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sn_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sn_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Sn_PT(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sn_PT(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_Sn_PT__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_Sn_PT__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_Sn_PT__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_Sn_PT__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_Sn_PT__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_Sn_PT__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_Sn_PT__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Sn_PT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Sn_PT(int const,double const,std::string const,std::string const,std::string const,int const,double const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::Sn_PT(int const,double const,std::string const,std::string const,std::string const,int const,double const,double const) const\n"
    "    cosmobl::Cosmology::Sn_PT(int const,double const,std::string const,std::string const,std::string const,int const,double const) const\n"
    "    cosmobl::Cosmology::Sn_PT(int const,double const,std::string const,std::string const,std::string const,int const) const\n"
    "    cosmobl::Cosmology::Sn_PT(int const,double const,std::string const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::Sn_PT(int const,double const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::Sn_PT(int const,double const,std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sigman_PT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_Sigman_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sigman_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sigman_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sigman_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Sigman_PT" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Sigman_PT" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_Sigman_PT" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Sigman_PT(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sigman_PT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_Sigman_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sigman_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sigman_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sigman_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Sigman_PT" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Sigman_PT" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_Sigman_PT" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)((cosmobl::Cosmology const *)arg1)->Sigman_PT(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sigman_PT__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_Sigman_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sigman_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sigman_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sigman_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Sigman_PT" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Sigman_PT" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)((cosmobl::Cosmology const *)arg1)->Sigman_PT(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sigman_PT__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_Sigman_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sigman_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sigman_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sigman_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Sigman_PT" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)((cosmobl::Cosmology const *)arg1)->Sigman_PT(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sigman_PT__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_Sigman_PT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sigman_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sigman_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sigman_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Sigman_PT(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sigman_PT__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_Sigman_PT",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sigman_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sigman_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sigman_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Sigman_PT(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sigman_PT__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Sigman_PT",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Sigman_PT" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Sigman_PT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_Sigman_PT" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Sigman_PT" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->Sigman_PT(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Sigman_PT(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_Sigman_PT__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_Sigman_PT__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_Sigman_PT__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_Sigman_PT__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_Sigman_PT__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_Sigman_PT__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_Sigman_PT__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Sigman_PT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Sigman_PT(int const,double const,std::string const,std::string const,std::string const,int const,double const,double const,std::string const) const\n"
    "    cosmobl::Cosmology::Sigman_PT(int const,double const,std::string const,std::string const,std::string const,int const,double const,double const) const\n"
    "    cosmobl::Cosmology::Sigman_PT(int const,double const,std::string const,std::string const,std::string const,int const,double const) const\n"
    "    cosmobl::Cosmology::Sigman_PT(int const,double const,std::string const,std::string const,std::string const,int const) const\n"
    "    cosmobl::Cosmology::Sigman_PT(int const,double const,std::string const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::Sigman_PT(int const,double const,std::string const,std::string const) const\n"
    "    cosmobl::Cosmology::Sigman_PT(int const,double const,std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  std::string arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi0_Kaiser" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xi0_Kaiser" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_xi0_Kaiser" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_xi0_Kaiser" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi0_Kaiser" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi0_Kaiser" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi0_Kaiser" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj18, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "19"" of type '" "std::string const""'"); 
    }
    arg19 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi0_Kaiser" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xi0_Kaiser" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_xi0_Kaiser" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_xi0_Kaiser" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi0_Kaiser" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi0_Kaiser" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi0_Kaiser" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi0_Kaiser" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xi0_Kaiser" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_xi0_Kaiser" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_xi0_Kaiser" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi0_Kaiser" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi0_Kaiser" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi0_Kaiser" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xi0_Kaiser" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_xi0_Kaiser" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_xi0_Kaiser" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi0_Kaiser" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi0_Kaiser" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xi0_Kaiser" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_xi0_Kaiser" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_xi0_Kaiser" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi0_Kaiser" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xi0_Kaiser" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_xi0_Kaiser" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi0_Kaiser" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xi0_Kaiser" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xi0_Kaiser" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi0_Kaiser" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi0_Kaiser" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi0_Kaiser" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi0_Kaiser" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_xi0_Kaiser",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi0_Kaiser" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi0_Kaiser" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi0_Kaiser" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi0_Kaiser" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi0_Kaiser" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi0_Kaiser" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->xi0_Kaiser(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi0_Kaiser(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[20] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 19) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_xi0_Kaiser__SWIG_13(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Cosmology_xi0_Kaiser__SWIG_12(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_xi0_Kaiser__SWIG_11(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_xi0_Kaiser__SWIG_10(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_xi0_Kaiser__SWIG_9(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_xi0_Kaiser__SWIG_8(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_xi0_Kaiser__SWIG_7(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_xi0_Kaiser__SWIG_6(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_xi0_Kaiser__SWIG_5(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_xi0_Kaiser__SWIG_4(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_xi0_Kaiser__SWIG_3(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_xi0_Kaiser__SWIG_2(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_xi0_Kaiser__SWIG_1(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        int res = SWIG_AsPtr_std_string(argv[18], (std::string**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_Cosmology_xi0_Kaiser__SWIG_0(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_xi0_Kaiser'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const,double const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const,int const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const,bool const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi0_Kaiser(double const,double const,double const,std::string const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  double arg29 ;
  double arg30 ;
  bool arg31 ;
  double arg32 ;
  std::string arg33 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  double val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  bool val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  PyObject * obj32 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31,&obj32)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_double(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "29"" of type '" "double""'");
  } 
  arg29 = static_cast< double >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_bool(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "31"" of type '" "bool""'");
  } 
  arg31 = static_cast< bool >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj32, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "33"" of type '" "std::string const""'"); 
    }
    arg33 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32,arg33);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  double arg29 ;
  double arg30 ;
  bool arg31 ;
  double arg32 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  double val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  bool val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_double(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "29"" of type '" "double""'");
  } 
  arg29 = static_cast< double >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_bool(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "31"" of type '" "bool""'");
  } 
  arg31 = static_cast< bool >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  double arg29 ;
  double arg30 ;
  bool arg31 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  double val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  bool val31 ;
  int ecode31 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_double(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "29"" of type '" "double""'");
  } 
  arg29 = static_cast< double >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_bool(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "31"" of type '" "bool""'");
  } 
  arg31 = static_cast< bool >(val31);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  double arg29 ;
  double arg30 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  double val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_double(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "29"" of type '" "double""'");
  } 
  arg29 = static_cast< double >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  double arg29 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  double val29 ;
  int ecode29 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_double(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "29"" of type '" "double""'");
  } 
  arg29 = static_cast< double >(val29);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  double arg26 ;
  double arg27 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  double arg26 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  int arg25 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  int arg24 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  int val24 ;
  int ecode24 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_int(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "24"" of type '" "int""'");
  } 
  arg24 = static_cast< int >(val24);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  double arg23 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  double arg22 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  bool arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  double arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  bool arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  int arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15,arg16);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  std::string arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  double arg8 ;
  int arg9 ;
  bool arg10 ;
  SwigValueWrapper< std::vector< double > > arg11 ;
  std::vector< double > *arg12 = 0 ;
  std::vector< double > *arg13 = 0 ;
  std::vector< double > *arg14 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "11"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "12"" of type '" "std::vector< double > &""'"); 
  }
  arg12 = reinterpret_cast< std::vector< double > * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "13"" of type '" "std::vector< double > &""'"); 
  }
  arg13 = reinterpret_cast< std::vector< double > * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_DispersionModel" "', argument " "14"" of type '" "std::vector< double > &""'"); 
  }
  arg14 = reinterpret_cast< std::vector< double > * >(argp14);
  result = (double)(arg1)->xi2D_DispersionModel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,*arg12,*arg13,*arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_DispersionModel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[34] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 33) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_Cosmology_xi2D_DispersionModel__SWIG_19(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_Cosmology_xi2D_DispersionModel__SWIG_18(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Cosmology_xi2D_DispersionModel__SWIG_17(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_Cosmology_xi2D_DispersionModel__SWIG_16(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_Cosmology_xi2D_DispersionModel__SWIG_15(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_Cosmology_xi2D_DispersionModel__SWIG_14(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_Cosmology_xi2D_DispersionModel__SWIG_13(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_Cosmology_xi2D_DispersionModel__SWIG_12(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 22) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                return _wrap_Cosmology_xi2D_DispersionModel__SWIG_11(self, args);
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 23) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  return _wrap_Cosmology_xi2D_DispersionModel__SWIG_10(self, args);
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 24) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    return _wrap_Cosmology_xi2D_DispersionModel__SWIG_9(self, args);
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 25) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      return _wrap_Cosmology_xi2D_DispersionModel__SWIG_8(self, args);
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 26) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        return _wrap_Cosmology_xi2D_DispersionModel__SWIG_7(self, args);
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 27) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          return _wrap_Cosmology_xi2D_DispersionModel__SWIG_6(self, args);
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 28) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            return _wrap_Cosmology_xi2D_DispersionModel__SWIG_5(self, args);
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 29) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_double(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              return _wrap_Cosmology_xi2D_DispersionModel__SWIG_4(self, args);
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 30) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_double(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                return _wrap_Cosmology_xi2D_DispersionModel__SWIG_3(self, args);
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 31) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_double(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_bool(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  return _wrap_Cosmology_xi2D_DispersionModel__SWIG_2(self, args);
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 32) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_double(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_bool(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    return _wrap_Cosmology_xi2D_DispersionModel__SWIG_1(self, args);
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 33) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_int(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_double(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_bool(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    int res = SWIG_AsPtr_std_string(argv[32], (std::string**)(0));
                                                                    _v = SWIG_CheckState(res);
                                                                    if (_v) {
                                                                      return _wrap_Cosmology_xi2D_DispersionModel__SWIG_0(self, args);
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_xi2D_DispersionModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const,double const,double const,double const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const,double const,double const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const,double const,double const,double const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const,int const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const,int const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const,bool const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,int const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const)\n"
    "    cosmobl::Cosmology::xi2D_DispersionModel(double const,double const,double const,double const,double const,std::string const,double const,int const,bool const,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_xi_star",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_star" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi_star" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_star" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_star" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_star" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_star" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_star" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi_star(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_xi_star",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_star" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi_star" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_star" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_star" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_star" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi_star" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->xi_star(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_xi_star",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_star" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi_star" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_star" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_star" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi_star" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (double)(arg1)->xi_star(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_xi_star",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_star" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi_star" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_star" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi_star" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->xi_star(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_xi_star",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_star" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi_star" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi_star" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->xi_star(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_xi_star",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_star" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi_star" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->xi_star(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_xi_star",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_star" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi_star" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi_star(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_xi_star",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi_star" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi_star" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi_star" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->xi_star(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi_star(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_xi_star__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_xi_star__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_xi_star__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_xi_star__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_xi_star__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_xi_star__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_xi_star__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_xi_star__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_xi_star'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::xi_star(double const,double const,std::string const,double const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi_star(double const,double const,std::string const,double const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi_star(double const,double const,std::string const,double const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi_star(double const,double const,std::string const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi_star(double const,double const,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::xi_star(double const,double const,std::string const,double const)\n"
    "    cosmobl::Cosmology::xi_star(double const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi_star(double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_xisnl_gnw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  std::vector< double > *arg10 = 0 ;
  std::vector< double > *arg11 = 0 ;
  std::string arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_xisnl_gnw",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xisnl_gnw" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xisnl_gnw" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xisnl_gnw" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xisnl_gnw" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xisnl_gnw" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xisnl_gnw" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xisnl_gnw" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Cosmology_xisnl_gnw" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xisnl_gnw" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Cosmology_xisnl_gnw" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xisnl_gnw" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Cosmology_xisnl_gnw" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xisnl_gnw" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xisnl_gnw" "', argument " "11"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xisnl_gnw" "', argument " "11"" of type '" "std::vector< double > &""'"); 
  }
  arg11 = reinterpret_cast< std::vector< double > * >(argp11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xisnl_gnw" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xisnl_gnw(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,*arg10,*arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xisnl_gnw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  std::vector< double > *arg10 = 0 ;
  std::vector< double > *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_xisnl_gnw",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xisnl_gnw" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xisnl_gnw" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xisnl_gnw" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xisnl_gnw" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xisnl_gnw" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xisnl_gnw" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xisnl_gnw" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Cosmology_xisnl_gnw" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xisnl_gnw" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Cosmology_xisnl_gnw" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xisnl_gnw" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Cosmology_xisnl_gnw" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xisnl_gnw" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Cosmology_xisnl_gnw" "', argument " "11"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xisnl_gnw" "', argument " "11"" of type '" "std::vector< double > &""'"); 
  }
  arg11 = reinterpret_cast< std::vector< double > * >(argp11);
  result = (double)(arg1)->xisnl_gnw(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,*arg10,*arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xisnl_gnw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[13] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 12) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_xisnl_gnw__SWIG_1(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_Cosmology_xisnl_gnw__SWIG_0(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_xisnl_gnw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::xisnl_gnw(double const,double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > &,std::vector< double > &,std::string const)\n"
    "    cosmobl::Cosmology::xisnl_gnw(double const,double const,double const,double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< double > &,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_xis_gBAO__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  std::vector< double > *arg9 = 0 ;
  std::vector< double > *arg10 = 0 ;
  std::string arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  int arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Cosmology_xis_gBAO",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xis_gBAO" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xis_gBAO" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xis_gBAO" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xis_gBAO" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xis_gBAO" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xis_gBAO" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  arg9 = reinterpret_cast< std::vector< double > * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xis_gBAO" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xis_gBAO" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xis_gBAO" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_xis_gBAO" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Cosmology_xis_gBAO" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  result = (double)(arg1)->xis_gBAO(arg2,arg3,arg4,arg5,arg6,arg7,arg8,*arg9,*arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xis_gBAO__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  std::vector< double > *arg9 = 0 ;
  std::vector< double > *arg10 = 0 ;
  std::string arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_xis_gBAO",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xis_gBAO" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xis_gBAO" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xis_gBAO" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xis_gBAO" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xis_gBAO" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xis_gBAO" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  arg9 = reinterpret_cast< std::vector< double > * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xis_gBAO" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xis_gBAO" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xis_gBAO" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Cosmology_xis_gBAO" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (double)(arg1)->xis_gBAO(arg2,arg3,arg4,arg5,arg6,arg7,arg8,*arg9,*arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xis_gBAO__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  std::vector< double > *arg9 = 0 ;
  std::vector< double > *arg10 = 0 ;
  std::string arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_xis_gBAO",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xis_gBAO" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xis_gBAO" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xis_gBAO" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xis_gBAO" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xis_gBAO" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xis_gBAO" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  arg9 = reinterpret_cast< std::vector< double > * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xis_gBAO" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xis_gBAO" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_xis_gBAO" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->xis_gBAO(arg2,arg3,arg4,arg5,arg6,arg7,arg8,*arg9,*arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xis_gBAO__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  std::vector< double > *arg9 = 0 ;
  std::vector< double > *arg10 = 0 ;
  std::string arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_xis_gBAO",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xis_gBAO" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xis_gBAO" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xis_gBAO" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xis_gBAO" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xis_gBAO" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xis_gBAO" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  arg9 = reinterpret_cast< std::vector< double > * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xis_gBAO" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_xis_gBAO" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (double)(arg1)->xis_gBAO(arg2,arg3,arg4,arg5,arg6,arg7,arg8,*arg9,*arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xis_gBAO__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  std::vector< double > *arg9 = 0 ;
  std::vector< double > *arg10 = 0 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_xis_gBAO",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xis_gBAO" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xis_gBAO" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xis_gBAO" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xis_gBAO" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xis_gBAO" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xis_gBAO" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  arg9 = reinterpret_cast< std::vector< double > * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xis_gBAO" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xis_gBAO(arg2,arg3,arg4,arg5,arg6,arg7,arg8,*arg9,*arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xis_gBAO__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  std::vector< double > *arg9 = 0 ;
  std::vector< double > *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_xis_gBAO",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xis_gBAO" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xis_gBAO" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xis_gBAO" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xis_gBAO" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xis_gBAO" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xis_gBAO" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "7"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "8"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "9"" of type '" "std::vector< double > &""'"); 
  }
  arg9 = reinterpret_cast< std::vector< double > * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xis_gBAO" "', argument " "10"" of type '" "std::vector< double > &""'"); 
  }
  arg10 = reinterpret_cast< std::vector< double > * >(argp10);
  result = (double)(arg1)->xis_gBAO(arg2,arg3,arg4,arg5,arg6,arg7,arg8,*arg9,*arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xis_gBAO(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[16] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 15) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_xis_gBAO__SWIG_5(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_xis_gBAO__SWIG_4(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_xis_gBAO__SWIG_3(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_xis_gBAO__SWIG_2(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Cosmology_xis_gBAO__SWIG_1(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Cosmology_xis_gBAO__SWIG_0(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_xis_gBAO'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::xis_gBAO(double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,double const,double const,int const)\n"
    "    cosmobl::Cosmology::xis_gBAO(double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xis_gBAO(double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const,double const)\n"
    "    cosmobl::Cosmology::xis_gBAO(double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const,double const)\n"
    "    cosmobl::Cosmology::xis_gBAO(double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::string const)\n"
    "    cosmobl::Cosmology::xis_gBAO(double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  double arg31 ;
  double arg32 ;
  double arg33 ;
  int arg34 ;
  double arg35 ;
  bool arg36 ;
  double arg37 ;
  std::string arg38 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  double val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  double val33 ;
  int ecode33 = 0 ;
  int val34 ;
  int ecode34 = 0 ;
  double val35 ;
  int ecode35 = 0 ;
  bool val36 ;
  int ecode36 = 0 ;
  double val37 ;
  int ecode37 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  PyObject * obj32 = 0 ;
  PyObject * obj33 = 0 ;
  PyObject * obj34 = 0 ;
  PyObject * obj35 = 0 ;
  PyObject * obj36 = 0 ;
  PyObject * obj37 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31,&obj32,&obj33,&obj34,&obj35,&obj36,&obj37)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_double(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_CW" "', argument " "31"" of type '" "double""'");
  } 
  arg31 = static_cast< double >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_CW" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  ecode33 = SWIG_AsVal_double(obj32, &val33);
  if (!SWIG_IsOK(ecode33)) {
    SWIG_exception_fail(SWIG_ArgError(ecode33), "in method '" "Cosmology_xi2D_CW" "', argument " "33"" of type '" "double""'");
  } 
  arg33 = static_cast< double >(val33);
  ecode34 = SWIG_AsVal_int(obj33, &val34);
  if (!SWIG_IsOK(ecode34)) {
    SWIG_exception_fail(SWIG_ArgError(ecode34), "in method '" "Cosmology_xi2D_CW" "', argument " "34"" of type '" "int""'");
  } 
  arg34 = static_cast< int >(val34);
  ecode35 = SWIG_AsVal_double(obj34, &val35);
  if (!SWIG_IsOK(ecode35)) {
    SWIG_exception_fail(SWIG_ArgError(ecode35), "in method '" "Cosmology_xi2D_CW" "', argument " "35"" of type '" "double""'");
  } 
  arg35 = static_cast< double >(val35);
  ecode36 = SWIG_AsVal_bool(obj35, &val36);
  if (!SWIG_IsOK(ecode36)) {
    SWIG_exception_fail(SWIG_ArgError(ecode36), "in method '" "Cosmology_xi2D_CW" "', argument " "36"" of type '" "bool""'");
  } 
  arg36 = static_cast< bool >(val36);
  ecode37 = SWIG_AsVal_double(obj36, &val37);
  if (!SWIG_IsOK(ecode37)) {
    SWIG_exception_fail(SWIG_ArgError(ecode37), "in method '" "Cosmology_xi2D_CW" "', argument " "37"" of type '" "double""'");
  } 
  arg37 = static_cast< double >(val37);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj37, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "38"" of type '" "std::string const""'"); 
    }
    arg38 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32,arg33,arg34,arg35,arg36,arg37,arg38);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  double arg31 ;
  double arg32 ;
  double arg33 ;
  int arg34 ;
  double arg35 ;
  bool arg36 ;
  double arg37 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  double val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  double val33 ;
  int ecode33 = 0 ;
  int val34 ;
  int ecode34 = 0 ;
  double val35 ;
  int ecode35 = 0 ;
  bool val36 ;
  int ecode36 = 0 ;
  double val37 ;
  int ecode37 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  PyObject * obj32 = 0 ;
  PyObject * obj33 = 0 ;
  PyObject * obj34 = 0 ;
  PyObject * obj35 = 0 ;
  PyObject * obj36 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31,&obj32,&obj33,&obj34,&obj35,&obj36)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_double(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_CW" "', argument " "31"" of type '" "double""'");
  } 
  arg31 = static_cast< double >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_CW" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  ecode33 = SWIG_AsVal_double(obj32, &val33);
  if (!SWIG_IsOK(ecode33)) {
    SWIG_exception_fail(SWIG_ArgError(ecode33), "in method '" "Cosmology_xi2D_CW" "', argument " "33"" of type '" "double""'");
  } 
  arg33 = static_cast< double >(val33);
  ecode34 = SWIG_AsVal_int(obj33, &val34);
  if (!SWIG_IsOK(ecode34)) {
    SWIG_exception_fail(SWIG_ArgError(ecode34), "in method '" "Cosmology_xi2D_CW" "', argument " "34"" of type '" "int""'");
  } 
  arg34 = static_cast< int >(val34);
  ecode35 = SWIG_AsVal_double(obj34, &val35);
  if (!SWIG_IsOK(ecode35)) {
    SWIG_exception_fail(SWIG_ArgError(ecode35), "in method '" "Cosmology_xi2D_CW" "', argument " "35"" of type '" "double""'");
  } 
  arg35 = static_cast< double >(val35);
  ecode36 = SWIG_AsVal_bool(obj35, &val36);
  if (!SWIG_IsOK(ecode36)) {
    SWIG_exception_fail(SWIG_ArgError(ecode36), "in method '" "Cosmology_xi2D_CW" "', argument " "36"" of type '" "bool""'");
  } 
  arg36 = static_cast< bool >(val36);
  ecode37 = SWIG_AsVal_double(obj36, &val37);
  if (!SWIG_IsOK(ecode37)) {
    SWIG_exception_fail(SWIG_ArgError(ecode37), "in method '" "Cosmology_xi2D_CW" "', argument " "37"" of type '" "double""'");
  } 
  arg37 = static_cast< double >(val37);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32,arg33,arg34,arg35,arg36,arg37);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  double arg31 ;
  double arg32 ;
  double arg33 ;
  int arg34 ;
  double arg35 ;
  bool arg36 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  double val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  double val33 ;
  int ecode33 = 0 ;
  int val34 ;
  int ecode34 = 0 ;
  double val35 ;
  int ecode35 = 0 ;
  bool val36 ;
  int ecode36 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  PyObject * obj32 = 0 ;
  PyObject * obj33 = 0 ;
  PyObject * obj34 = 0 ;
  PyObject * obj35 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31,&obj32,&obj33,&obj34,&obj35)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_double(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_CW" "', argument " "31"" of type '" "double""'");
  } 
  arg31 = static_cast< double >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_CW" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  ecode33 = SWIG_AsVal_double(obj32, &val33);
  if (!SWIG_IsOK(ecode33)) {
    SWIG_exception_fail(SWIG_ArgError(ecode33), "in method '" "Cosmology_xi2D_CW" "', argument " "33"" of type '" "double""'");
  } 
  arg33 = static_cast< double >(val33);
  ecode34 = SWIG_AsVal_int(obj33, &val34);
  if (!SWIG_IsOK(ecode34)) {
    SWIG_exception_fail(SWIG_ArgError(ecode34), "in method '" "Cosmology_xi2D_CW" "', argument " "34"" of type '" "int""'");
  } 
  arg34 = static_cast< int >(val34);
  ecode35 = SWIG_AsVal_double(obj34, &val35);
  if (!SWIG_IsOK(ecode35)) {
    SWIG_exception_fail(SWIG_ArgError(ecode35), "in method '" "Cosmology_xi2D_CW" "', argument " "35"" of type '" "double""'");
  } 
  arg35 = static_cast< double >(val35);
  ecode36 = SWIG_AsVal_bool(obj35, &val36);
  if (!SWIG_IsOK(ecode36)) {
    SWIG_exception_fail(SWIG_ArgError(ecode36), "in method '" "Cosmology_xi2D_CW" "', argument " "36"" of type '" "bool""'");
  } 
  arg36 = static_cast< bool >(val36);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32,arg33,arg34,arg35,arg36);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  double arg31 ;
  double arg32 ;
  double arg33 ;
  int arg34 ;
  double arg35 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  double val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  double val33 ;
  int ecode33 = 0 ;
  int val34 ;
  int ecode34 = 0 ;
  double val35 ;
  int ecode35 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  PyObject * obj32 = 0 ;
  PyObject * obj33 = 0 ;
  PyObject * obj34 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31,&obj32,&obj33,&obj34)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_double(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_CW" "', argument " "31"" of type '" "double""'");
  } 
  arg31 = static_cast< double >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_CW" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  ecode33 = SWIG_AsVal_double(obj32, &val33);
  if (!SWIG_IsOK(ecode33)) {
    SWIG_exception_fail(SWIG_ArgError(ecode33), "in method '" "Cosmology_xi2D_CW" "', argument " "33"" of type '" "double""'");
  } 
  arg33 = static_cast< double >(val33);
  ecode34 = SWIG_AsVal_int(obj33, &val34);
  if (!SWIG_IsOK(ecode34)) {
    SWIG_exception_fail(SWIG_ArgError(ecode34), "in method '" "Cosmology_xi2D_CW" "', argument " "34"" of type '" "int""'");
  } 
  arg34 = static_cast< int >(val34);
  ecode35 = SWIG_AsVal_double(obj34, &val35);
  if (!SWIG_IsOK(ecode35)) {
    SWIG_exception_fail(SWIG_ArgError(ecode35), "in method '" "Cosmology_xi2D_CW" "', argument " "35"" of type '" "double""'");
  } 
  arg35 = static_cast< double >(val35);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32,arg33,arg34,arg35);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  double arg31 ;
  double arg32 ;
  double arg33 ;
  int arg34 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  double val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  double val33 ;
  int ecode33 = 0 ;
  int val34 ;
  int ecode34 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  PyObject * obj32 = 0 ;
  PyObject * obj33 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31,&obj32,&obj33)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_double(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_CW" "', argument " "31"" of type '" "double""'");
  } 
  arg31 = static_cast< double >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_CW" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  ecode33 = SWIG_AsVal_double(obj32, &val33);
  if (!SWIG_IsOK(ecode33)) {
    SWIG_exception_fail(SWIG_ArgError(ecode33), "in method '" "Cosmology_xi2D_CW" "', argument " "33"" of type '" "double""'");
  } 
  arg33 = static_cast< double >(val33);
  ecode34 = SWIG_AsVal_int(obj33, &val34);
  if (!SWIG_IsOK(ecode34)) {
    SWIG_exception_fail(SWIG_ArgError(ecode34), "in method '" "Cosmology_xi2D_CW" "', argument " "34"" of type '" "int""'");
  } 
  arg34 = static_cast< int >(val34);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32,arg33,arg34);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  double arg31 ;
  double arg32 ;
  double arg33 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  double val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  double val33 ;
  int ecode33 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  PyObject * obj32 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31,&obj32)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_double(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_CW" "', argument " "31"" of type '" "double""'");
  } 
  arg31 = static_cast< double >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_CW" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  ecode33 = SWIG_AsVal_double(obj32, &val33);
  if (!SWIG_IsOK(ecode33)) {
    SWIG_exception_fail(SWIG_ArgError(ecode33), "in method '" "Cosmology_xi2D_CW" "', argument " "33"" of type '" "double""'");
  } 
  arg33 = static_cast< double >(val33);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32,arg33);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  double arg31 ;
  double arg32 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  double val31 ;
  int ecode31 = 0 ;
  double val32 ;
  int ecode32 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_double(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_CW" "', argument " "31"" of type '" "double""'");
  } 
  arg31 = static_cast< double >(val31);
  ecode32 = SWIG_AsVal_double(obj31, &val32);
  if (!SWIG_IsOK(ecode32)) {
    SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "Cosmology_xi2D_CW" "', argument " "32"" of type '" "double""'");
  } 
  arg32 = static_cast< double >(val32);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  double arg31 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  double val31 ;
  int ecode31 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  ecode31 = SWIG_AsVal_double(obj30, &val31);
  if (!SWIG_IsOK(ecode31)) {
    SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "Cosmology_xi2D_CW" "', argument " "31"" of type '" "double""'");
  } 
  arg31 = static_cast< double >(val31);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  double arg30 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  double val30 ;
  int ecode30 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  ecode30 = SWIG_AsVal_double(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "Cosmology_xi2D_CW" "', argument " "30"" of type '" "double""'");
  } 
  arg30 = static_cast< double >(val30);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  int arg29 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  ecode29 = SWIG_AsVal_int(obj28, &val29);
  if (!SWIG_IsOK(ecode29)) {
    SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "Cosmology_xi2D_CW" "', argument " "29"" of type '" "int""'");
  } 
  arg29 = static_cast< int >(val29);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  double arg28 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "Cosmology_xi2D_CW" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  double arg27 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  double val27 ;
  int ecode27 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_double(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "Cosmology_xi2D_CW" "', argument " "27"" of type '" "double""'");
  } 
  arg27 = static_cast< double >(val27);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  double arg26 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "Cosmology_xi2D_CW" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "Cosmology_xi2D_CW" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24,arg25);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  bool arg24 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "Cosmology_xi2D_CW" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23,arg24);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  double arg23 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "Cosmology_xi2D_CW" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22,arg23);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  bool arg22 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  bool val22 ;
  int ecode22 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  ecode22 = SWIG_AsVal_bool(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "Cosmology_xi2D_CW" "', argument " "22"" of type '" "bool""'");
  } 
  arg22 = static_cast< bool >(val22);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21,arg22);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  bool arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  bool val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_bool(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "Cosmology_xi2D_CW" "', argument " "21"" of type '" "bool""'");
  } 
  arg21 = static_cast< bool >(val21);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20,arg21);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  std::string arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_xi2D_CW" "', argument " "20"" of type '" "std::string const""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19,arg20);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SwigValueWrapper< std::vector< double > > arg12 ;
  SwigValueWrapper< std::vector< double > > arg13 ;
  SwigValueWrapper< std::vector< double > > arg14 ;
  SwigValueWrapper< std::vector< double > > arg15 ;
  std::vector< double > *arg16 = 0 ;
  std::vector< double > *arg17 = 0 ;
  std::vector< double > *arg18 = 0 ;
  std::vector< double > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:Cosmology_xi2D_CW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_xi2D_CW" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_xi2D_CW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_xi2D_CW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_xi2D_CW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_xi2D_CW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_xi2D_CW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_xi2D_CW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_xi2D_CW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_xi2D_CW" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_xi2D_CW" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_xi2D_CW" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "12"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "13"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "14"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp14);
      arg14 = *temp;
      if (SWIG_IsNewObj(res14)) delete temp;
    }
  }
  {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "15"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp15);
      arg15 = *temp;
      if (SWIG_IsNewObj(res15)) delete temp;
    }
  }
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "16"" of type '" "std::vector< double > &""'"); 
  }
  arg16 = reinterpret_cast< std::vector< double > * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "17"" of type '" "std::vector< double > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< double > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "18"" of type '" "std::vector< double > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< double > * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_xi2D_CW" "', argument " "19"" of type '" "std::vector< double > &""'"); 
  }
  arg19 = reinterpret_cast< std::vector< double > * >(argp19);
  result = (double)(arg1)->xi2D_CW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,*arg16,*arg17,*arg18,*arg19);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_xi2D_CW(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[39] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 38) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_Cosmology_xi2D_CW__SWIG_19(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_Cosmology_xi2D_CW__SWIG_18(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_Cosmology_xi2D_CW__SWIG_17(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 22) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                return _wrap_Cosmology_xi2D_CW__SWIG_16(self, args);
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 23) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  return _wrap_Cosmology_xi2D_CW__SWIG_15(self, args);
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 24) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    return _wrap_Cosmology_xi2D_CW__SWIG_14(self, args);
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 25) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      return _wrap_Cosmology_xi2D_CW__SWIG_13(self, args);
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 26) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        return _wrap_Cosmology_xi2D_CW__SWIG_12(self, args);
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 27) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          return _wrap_Cosmology_xi2D_CW__SWIG_11(self, args);
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 28) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            return _wrap_Cosmology_xi2D_CW__SWIG_10(self, args);
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 29) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              return _wrap_Cosmology_xi2D_CW__SWIG_9(self, args);
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 30) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                return _wrap_Cosmology_xi2D_CW__SWIG_8(self, args);
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 31) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_double(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  return _wrap_Cosmology_xi2D_CW__SWIG_7(self, args);
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 32) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_double(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    return _wrap_Cosmology_xi2D_CW__SWIG_6(self, args);
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 33) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_double(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    {
                                                                      int res = SWIG_AsVal_double(argv[32], NULL);
                                                                      _v = SWIG_CheckState(res);
                                                                    }
                                                                    if (_v) {
                                                                      return _wrap_Cosmology_xi2D_CW__SWIG_5(self, args);
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 34) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_double(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    {
                                                                      int res = SWIG_AsVal_double(argv[32], NULL);
                                                                      _v = SWIG_CheckState(res);
                                                                    }
                                                                    if (_v) {
                                                                      {
                                                                        int res = SWIG_AsVal_int(argv[33], NULL);
                                                                        _v = SWIG_CheckState(res);
                                                                      }
                                                                      if (_v) {
                                                                        return _wrap_Cosmology_xi2D_CW__SWIG_4(self, args);
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 35) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_double(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    {
                                                                      int res = SWIG_AsVal_double(argv[32], NULL);
                                                                      _v = SWIG_CheckState(res);
                                                                    }
                                                                    if (_v) {
                                                                      {
                                                                        int res = SWIG_AsVal_int(argv[33], NULL);
                                                                        _v = SWIG_CheckState(res);
                                                                      }
                                                                      if (_v) {
                                                                        {
                                                                          int res = SWIG_AsVal_double(argv[34], NULL);
                                                                          _v = SWIG_CheckState(res);
                                                                        }
                                                                        if (_v) {
                                                                          return _wrap_Cosmology_xi2D_CW__SWIG_3(self, args);
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 36) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_double(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    {
                                                                      int res = SWIG_AsVal_double(argv[32], NULL);
                                                                      _v = SWIG_CheckState(res);
                                                                    }
                                                                    if (_v) {
                                                                      {
                                                                        int res = SWIG_AsVal_int(argv[33], NULL);
                                                                        _v = SWIG_CheckState(res);
                                                                      }
                                                                      if (_v) {
                                                                        {
                                                                          int res = SWIG_AsVal_double(argv[34], NULL);
                                                                          _v = SWIG_CheckState(res);
                                                                        }
                                                                        if (_v) {
                                                                          {
                                                                            int res = SWIG_AsVal_bool(argv[35], NULL);
                                                                            _v = SWIG_CheckState(res);
                                                                          }
                                                                          if (_v) {
                                                                            return _wrap_Cosmology_xi2D_CW__SWIG_2(self, args);
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 37) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_double(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    {
                                                                      int res = SWIG_AsVal_double(argv[32], NULL);
                                                                      _v = SWIG_CheckState(res);
                                                                    }
                                                                    if (_v) {
                                                                      {
                                                                        int res = SWIG_AsVal_int(argv[33], NULL);
                                                                        _v = SWIG_CheckState(res);
                                                                      }
                                                                      if (_v) {
                                                                        {
                                                                          int res = SWIG_AsVal_double(argv[34], NULL);
                                                                          _v = SWIG_CheckState(res);
                                                                        }
                                                                        if (_v) {
                                                                          {
                                                                            int res = SWIG_AsVal_bool(argv[35], NULL);
                                                                            _v = SWIG_CheckState(res);
                                                                          }
                                                                          if (_v) {
                                                                            {
                                                                              int res = SWIG_AsVal_double(argv[36], NULL);
                                                                              _v = SWIG_CheckState(res);
                                                                            }
                                                                            if (_v) {
                                                                              return _wrap_Cosmology_xi2D_CW__SWIG_1(self, args);
                                                                            }
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 38) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      void *vptr = 0;
                                      int res = SWIG_ConvertPtr(argv[17], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        void *vptr = 0;
                                        int res = SWIG_ConvertPtr(argv[18], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_bool(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_bool(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_double(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            {
                                                              int res = SWIG_AsVal_int(argv[28], NULL);
                                                              _v = SWIG_CheckState(res);
                                                            }
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_double(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                {
                                                                  int res = SWIG_AsVal_double(argv[30], NULL);
                                                                  _v = SWIG_CheckState(res);
                                                                }
                                                                if (_v) {
                                                                  {
                                                                    int res = SWIG_AsVal_double(argv[31], NULL);
                                                                    _v = SWIG_CheckState(res);
                                                                  }
                                                                  if (_v) {
                                                                    {
                                                                      int res = SWIG_AsVal_double(argv[32], NULL);
                                                                      _v = SWIG_CheckState(res);
                                                                    }
                                                                    if (_v) {
                                                                      {
                                                                        int res = SWIG_AsVal_int(argv[33], NULL);
                                                                        _v = SWIG_CheckState(res);
                                                                      }
                                                                      if (_v) {
                                                                        {
                                                                          int res = SWIG_AsVal_double(argv[34], NULL);
                                                                          _v = SWIG_CheckState(res);
                                                                        }
                                                                        if (_v) {
                                                                          {
                                                                            int res = SWIG_AsVal_bool(argv[35], NULL);
                                                                            _v = SWIG_CheckState(res);
                                                                          }
                                                                          if (_v) {
                                                                            {
                                                                              int res = SWIG_AsVal_double(argv[36], NULL);
                                                                              _v = SWIG_CheckState(res);
                                                                            }
                                                                            if (_v) {
                                                                              int res = SWIG_AsPtr_std_string(argv[37], (std::string**)(0));
                                                                              _v = SWIG_CheckState(res);
                                                                              if (_v) {
                                                                                return _wrap_Cosmology_xi2D_CW__SWIG_0(self, args);
                                                                              }
                                                                            }
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_xi2D_CW'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const,double const,double const,double const,int const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const,double const,double const,double const,int const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const,double const,double const,double const,int const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const,double const,double const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const,double const,double const,double const,int const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const,int const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const,bool const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const,double const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const,bool const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const,bool const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::string const)\n"
    "    cosmobl::Cosmology::xi2D_CW(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_rs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_rs",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_rs" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_rs" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_rs" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((cosmobl::Cosmology const *)arg1)->rs(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_rs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_rs",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_rs" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_rs" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->rs(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_rs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Cosmology_rs__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Cosmology_rs__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_rs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::rs(std::string const,double const) const\n"
    "    cosmobl::Cosmology::rs(std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_rs_EH__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_rs_EH",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_rs_EH" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_rs_EH" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->rs_EH(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_rs_EH__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_rs_EH",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_rs_EH" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->rs_EH();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_rs_EH(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Cosmology_rs_EH__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Cosmology_rs_EH__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_rs_EH'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::rs_EH(double const) const\n"
    "    cosmobl::Cosmology::rs_EH() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_rs_CAMB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_rs_CAMB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_rs_CAMB" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->rs_CAMB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_ys__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_ys",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_ys" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_ys" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_ys" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_ys" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->ys(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_ys__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_ys",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_ys" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_ys" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_ys" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->ys(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_ys(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Cosmology_ys__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_ys__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_ys'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::ys(double const,std::string const,double const) const\n"
    "    cosmobl::Cosmology::ys(double const,std::string const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_Az(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_Az",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Az" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_Az" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->Az(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  std::string arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_Am",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Am" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Am" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Am" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Am" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Am" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Am" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->Am(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_Am",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Am" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Am" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Am" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Am" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Am" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_Am" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->Am(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_Am",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Am" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Am" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Am" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Am" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_Am" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (double)(arg1)->Am(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_Am",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Am" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Am" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Am" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_Am" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->Am(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_Am",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Am" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Am" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_Am" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->Am(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_Am",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Am" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_Am" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->Am(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_Am",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Am" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->Am(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_Am",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_Am" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_Am" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->Am(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_Am(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Cosmology_Am__SWIG_7(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Cosmology_Am__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_Am__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_Am__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_Am__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_Am__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_Am__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Cosmology_Am__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_Am'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::Am(std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::Am(std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::Am(std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::Am(std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::Am(std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::Am(std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::Am(std::string const,std::string const)\n"
    "    cosmobl::Cosmology::Am(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  std::string arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_potential_spectral_amplitude",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->potential_spectral_amplitude(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_potential_spectral_amplitude",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->potential_spectral_amplitude(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_potential_spectral_amplitude",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (double)(arg1)->potential_spectral_amplitude(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_potential_spectral_amplitude",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->potential_spectral_amplitude(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_potential_spectral_amplitude",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->potential_spectral_amplitude(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_potential_spectral_amplitude",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->potential_spectral_amplitude(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_potential_spectral_amplitude",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->potential_spectral_amplitude(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_potential_spectral_amplitude",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_potential_spectral_amplitude" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->potential_spectral_amplitude(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_potential_spectral_amplitude(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Cosmology_potential_spectral_amplitude__SWIG_7(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Cosmology_potential_spectral_amplitude__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Cosmology_potential_spectral_amplitude__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_potential_spectral_amplitude__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_potential_spectral_amplitude__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_potential_spectral_amplitude__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_potential_spectral_amplitude__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Cosmology_potential_spectral_amplitude__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_potential_spectral_amplitude'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::potential_spectral_amplitude(std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::potential_spectral_amplitude(std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::potential_spectral_amplitude(std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::potential_spectral_amplitude(std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::potential_spectral_amplitude(std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::potential_spectral_amplitude(std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::potential_spectral_amplitude(std::string const,std::string const)\n"
    "    cosmobl::Cosmology::potential_spectral_amplitude(std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_bispectrum",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bispectrum" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_bispectrum" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bispectrum" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bispectrum" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bispectrum" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bispectrum" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bispectrum(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_bispectrum",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bispectrum" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_bispectrum" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bispectrum" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bispectrum" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bispectrum" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bispectrum" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->bispectrum(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_bispectrum",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bispectrum" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_bispectrum" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bispectrum" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bispectrum" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bispectrum" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (double)(arg1)->bispectrum(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_bispectrum",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bispectrum" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_bispectrum" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bispectrum" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bispectrum" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->bispectrum(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_bispectrum",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bispectrum" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_bispectrum" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bispectrum" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->bispectrum(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_bispectrum",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bispectrum" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_bispectrum" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->bispectrum(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_bispectrum",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bispectrum" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bispectrum(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_bispectrum",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bispectrum" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cosmology_bispectrum" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bispectrum" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bispectrum(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bispectrum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Cosmology_bispectrum__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_bispectrum__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_bispectrum__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_bispectrum__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_bispectrum__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_bispectrum__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_bispectrum__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_bispectrum__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_bispectrum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::bispectrum(std::vector< double > const,std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::bispectrum(std::vector< double > const,std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::bispectrum(std::vector< double > const,std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::bispectrum(std::vector< double > const,std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::bispectrum(std::vector< double > const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::bispectrum(std::vector< double > const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::bispectrum(std::vector< double > const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bispectrum(std::vector< double > const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_mrk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mrk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mrk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mrk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_mrk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mrk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mrk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mrk" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mrk" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mrk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_mrk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mrk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mrk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mrk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_mrk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mrk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mrk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mrk" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_mrk" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->mrk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_mrk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mrk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mrk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mrk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_mrk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mrk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mrk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_mrk" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (double)(arg1)->mrk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_mrk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mrk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mrk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mrk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_mrk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mrk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_mrk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->mrk(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_mrk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mrk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mrk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mrk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_mrk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_mrk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->mrk(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_mrk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mrk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mrk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mrk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_mrk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->mrk(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_mrk",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mrk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mrk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mrk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mrk(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_mrk",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_mrk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_mrk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_mrk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_mrk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->mrk(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_mrk(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_mrk__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_mrk__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_mrk__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_mrk__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_mrk__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_mrk__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_mrk__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_mrk__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_mrk'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::mrk(double const,double const,std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::mrk(double const,double const,std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::mrk(double const,double const,std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::mrk(double const,double const,std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::mrk(double const,double const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::mrk(double const,double const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::mrk(double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::mrk(double const,double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_frk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_frk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_frk" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_frk" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->frk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_frk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_frk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_frk" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_frk" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->frk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_frk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_frk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_frk" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (double)(arg1)->frk(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_frk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_frk" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->frk(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_frk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->frk(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_frk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->frk(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_frk",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->frk(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_frk",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->frk(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_frk__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_frk__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_frk__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_frk__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_frk__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_frk__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_frk__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_frk__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_frk'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::frk(double const,double const,std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::frk(double const,double const,std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::frk(double const,double const,std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::frk(double const,double const,std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::frk(double const,double const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::frk(double const,double const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::frk(double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::frk(double const,double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_kernel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_bias_kernel",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_kernel" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_kernel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cosmology_bias_kernel" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)(arg1)->bias_kernel(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_frk_test",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk_test" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk_test" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk_test" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk_test" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk_test" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_frk_test" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_frk_test" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_frk_test" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->frk_test(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_frk_test",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk_test" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk_test" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk_test" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk_test" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk_test" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_frk_test" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_frk_test" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_frk_test" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->frk_test(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_frk_test",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk_test" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk_test" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk_test" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk_test" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk_test" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_frk_test" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_frk_test" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (double)(arg1)->frk_test(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_frk_test",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk_test" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk_test" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk_test" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk_test" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk_test" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_frk_test" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->frk_test(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_frk_test",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk_test" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk_test" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk_test" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk_test" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_frk_test" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->frk_test(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_frk_test",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk_test" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk_test" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk_test" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_frk_test" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->frk_test(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_frk_test",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk_test" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk_test" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk_test" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->frk_test(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_frk_test",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_frk_test" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_frk_test" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_frk_test" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_frk_test" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->frk_test(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_frk_test(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_frk_test__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_frk_test__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_frk_test__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_frk_test__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_frk_test__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_frk_test__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_frk_test__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_frk_test__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_frk_test'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::frk_test(double const,double const,std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::frk_test(double const,double const,std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::frk_test(double const,double const,std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::frk_test(double const,double const,std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::frk_test(double const,double const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::frk_test(double const,double const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::frk_test(double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::frk_test(double const,double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  std::string arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_bias_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bias_correction" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_correction" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_correction" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_correction" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_bias_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bias_correction" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_correction" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_correction" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_bias_correction" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->bias_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_bias_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bias_correction" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_correction" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_bias_correction" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (double)(arg1)->bias_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_bias_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bias_correction" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_correction" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_bias_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->bias_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_bias_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bias_correction" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_bias_correction" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->bias_correction(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_bias_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_bias_correction" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->bias_correction(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_bias_correction",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_correction(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_bias_correction",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_bias_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_bias_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_bias_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_bias_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->bias_correction(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_bias_correction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[12] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_bias_correction__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_bias_correction__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_bias_correction__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_bias_correction__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_bias_correction__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_bias_correction__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_bias_correction__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Cosmology_bias_correction__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_bias_correction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::bias_correction(double const,double const,std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::bias_correction(double const,double const,std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::bias_correction(double const,double const,std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::bias_correction(double const,double const,std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::bias_correction(double const,double const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::bias_correction(double const,double const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::bias_correction(double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::bias_correction(double const,double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_skewness",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_skewness" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_skewness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_skewness" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_skewness" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_skewness" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_skewness" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_skewness" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->skewness(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_skewness",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_skewness" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_skewness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_skewness" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_skewness" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_skewness" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_skewness" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_skewness" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->skewness(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_skewness",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_skewness" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_skewness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_skewness" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_skewness" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_skewness" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_skewness" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (double)(arg1)->skewness(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_skewness",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_skewness" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_skewness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_skewness" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_skewness" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_skewness" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->skewness(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_skewness",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_skewness" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_skewness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_skewness" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_skewness" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->skewness(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_skewness",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_skewness" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_skewness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_skewness" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->skewness(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_skewness",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_skewness" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_skewness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->skewness(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_skewness",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_skewness" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_skewness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_skewness" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->skewness(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_skewness(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Cosmology_skewness__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_skewness__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_skewness__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_skewness__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_skewness__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_skewness__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_skewness__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_skewness__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_skewness'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::skewness(double const,std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::skewness(double const,std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::skewness(double const,std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::skewness(double const,std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::skewness(double const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::skewness(double const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::skewness(double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::skewness(double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_dskewnessdM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dskewnessdM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dskewnessdM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dskewnessdM" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_dskewnessdM" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_dskewnessdM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dskewnessdM" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_dskewnessdM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->dskewnessdM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_dskewnessdM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dskewnessdM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dskewnessdM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dskewnessdM" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_dskewnessdM" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_dskewnessdM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dskewnessdM" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_dskewnessdM" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (double)(arg1)->dskewnessdM(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_dskewnessdM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dskewnessdM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dskewnessdM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dskewnessdM" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_dskewnessdM" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_dskewnessdM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_dskewnessdM" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (double)(arg1)->dskewnessdM(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_dskewnessdM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dskewnessdM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dskewnessdM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dskewnessdM" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_dskewnessdM" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_dskewnessdM" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->dskewnessdM(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_dskewnessdM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dskewnessdM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dskewnessdM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dskewnessdM" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_dskewnessdM" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->dskewnessdM(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_dskewnessdM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dskewnessdM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dskewnessdM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_dskewnessdM" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dskewnessdM(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_dskewnessdM",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dskewnessdM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dskewnessdM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->dskewnessdM(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Cosmology_dskewnessdM",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_dskewnessdM" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_dskewnessdM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_dskewnessdM" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->dskewnessdM(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_dskewnessdM(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Cosmology_dskewnessdM__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_dskewnessdM__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Cosmology_dskewnessdM__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Cosmology_dskewnessdM__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_dskewnessdM__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_dskewnessdM__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_dskewnessdM__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Cosmology_dskewnessdM__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_dskewnessdM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::dskewnessdM(double const,std::string const,std::string const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::dskewnessdM(double const,std::string const,std::string const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::dskewnessdM(double const,std::string const,std::string const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::dskewnessdM(double const,std::string const,std::string const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::dskewnessdM(double const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::dskewnessdM(double const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::dskewnessdM(double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::dskewnessdM(double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  std::string arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MF_correction" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MF_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MF_correction" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_MF_correction" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_MF_correction" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_MF_correction" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_MF_correction" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj13, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "14"" of type '" "std::string const""'"); 
    }
    arg14 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MF_correction" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MF_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MF_correction" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_MF_correction" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_MF_correction" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_MF_correction" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Cosmology_MF_correction" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MF_correction" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MF_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MF_correction" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_MF_correction" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_MF_correction" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_MF_correction" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MF_correction" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MF_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MF_correction" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_MF_correction" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_MF_correction" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  int arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MF_correction" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MF_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MF_correction" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_MF_correction" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MF_correction" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MF_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Cosmology_MF_correction" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MF_correction" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Cosmology_MF_correction" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Cosmology_MF_correction" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "6"" of type '" "std::string const""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_MF_correction",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_MF_correction" "', argument " "1"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_MF_correction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_MF_correction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_MF_correction" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->MF_correction(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_MF_correction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[15] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 14) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Cosmology_MF_correction__SWIG_10(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Cosmology_MF_correction__SWIG_9(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Cosmology_MF_correction__SWIG_8(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Cosmology_MF_correction__SWIG_7(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Cosmology_MF_correction__SWIG_6(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Cosmology_MF_correction__SWIG_5(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Cosmology_MF_correction__SWIG_4(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Cosmology_MF_correction__SWIG_3(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Cosmology_MF_correction__SWIG_2(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Cosmology_MF_correction__SWIG_1(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_AsPtr_std_string(argv[13], (std::string**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_Cosmology_MF_correction__SWIG_0(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_MF_correction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const,int const,double const,int const,double const,double const,bool const,double const,std::string const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const,int const,double const,int const,double const,double const,bool const,double const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const,int const,double const,int const,double const,double const,bool const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const,int const,double const,int const,double const,double const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const,int const,double const,int const,double const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const,int const,double const,int const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const,int const,double const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const,int const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const,std::string const)\n"
    "    cosmobl::Cosmology::MF_correction(double const,double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_VolS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_VolS",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_VolS" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_VolS" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->VolS(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_deltav__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_deltav",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_deltav" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_deltav" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->deltav(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_deltav__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_deltav",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_deltav" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->deltav();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_deltav(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Cosmology_deltav__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Cosmology_deltav__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_deltav'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::deltav(double const) const\n"
    "    cosmobl::Cosmology::deltav() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_r_rL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cosmology_r_rL",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_r_rL" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_r_rL" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((cosmobl::Cosmology const *)arg1)->r_rL(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_r_rL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cosmology_r_rL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_r_rL" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  result = (double)((cosmobl::Cosmology const *)arg1)->r_rL();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_r_rL(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Cosmology_r_rL__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Cosmology_r_rL__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Cosmology_r_rL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cosmology::r_rL(double const) const\n"
    "    cosmobl::Cosmology::r_rL() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Cosmology_f_nu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Cosmology_f_nu",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_f_nu" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_f_nu" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_f_nu" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_f_nu" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((cosmobl::Cosmology const *)arg1)->f_nu(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cosmology_size_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = (cosmobl::Cosmology *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  std::string arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  std::string arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Cosmology_size_function",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cosmology_size_function" "', argument " "1"" of type '" "cosmobl::Cosmology const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cosmology_size_function" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Cosmology_size_function" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Cosmology_size_function" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Cosmology_size_function" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Cosmology_size_function" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_size_function" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_size_function" "', argument " "8"" of type '" "std::string const""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_size_function" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Cosmology_size_function" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Cosmology_size_function" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Cosmology_size_function" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj12, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Cosmology_size_function" "', argument " "13"" of type '" "std::string const""'"); 
    }
    arg13 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)((cosmobl::Cosmology const *)arg1)->size_function(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Cosmology_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Cosmology, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_GSL_bias_kernel_wrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_bias_kernel_wrapper",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GSL_bias_kernel_wrapper" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GSL_bias_kernel_wrapper" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::glob::GSL_bias_kernel_wrapper(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_xi_EH_GSL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_xi_EH_GSL",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "func_xi_EH_GSL" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "func_xi_EH_GSL" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::glob::func_xi_EH_GSL(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_func_SSM_EH_GSL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:func_SSM_EH_GSL",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "func_SSM_EH_GSL" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "func_SSM_EH_GSL" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::glob::func_SSM_EH_GSL(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bias_kernel2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  void *arg2 = (void *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:bias_kernel2",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bias_kernel2" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bias_kernel2" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::glob::bias_kernel2(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_skewness_kernel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:skewness_kernel",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "skewness_kernel" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "skewness_kernel" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "skewness_kernel" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (double)cosmobl::glob::skewness_kernel(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_kt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_kt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_kt_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GSL_f_pars_kt_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->kt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_kt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_kt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_kt_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (double) ((arg1)->kt);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_mass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_mass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_mass_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GSL_f_pars_mass_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_mass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_mass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_mass_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (double) ((arg1)->mass);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_method_Pk_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_method_Pk_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_method_Pk_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GSL_f_pars_method_Pk_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GSL_f_pars_method_Pk_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->method_Pk = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_method_Pk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_method_Pk_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_method_Pk_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (std::string *) & ((arg1)->method_Pk);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_output_root_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_output_root_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_output_root_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GSL_f_pars_output_root_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GSL_f_pars_output_root_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->output_root = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_output_root_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_output_root_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_output_root_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (std::string *) & ((arg1)->output_root);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_norm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_norm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_norm_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GSL_f_pars_norm_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->norm = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_norm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_norm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_norm_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (int) ((arg1)->norm);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_k_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_k_min_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_k_min_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GSL_f_pars_k_min_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->k_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_k_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_k_min_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_k_min_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (double) ((arg1)->k_min);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_k_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_k_max_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_k_max_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GSL_f_pars_k_max_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->k_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_k_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_k_max_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_k_max_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (double) ((arg1)->k_max);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_GSL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_GSL_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_GSL_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GSL_f_pars_GSL_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->GSL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_GSL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_GSL_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_GSL_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (bool) ((arg1)->GSL);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_prec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_prec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_prec_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GSL_f_pars_prec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->prec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_prec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_prec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_prec_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (double) ((arg1)->prec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_file_par_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_file_par_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_file_par_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GSL_f_pars_file_par_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GSL_f_pars_file_par_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->file_par = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_file_par_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_file_par_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_file_par_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (std::string *) & ((arg1)->file_par);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_pt_Cosmology_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  cosmobl::Cosmology *arg2 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GSL_f_pars_pt_Cosmology_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_pt_Cosmology_set" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cosmobl__Cosmology, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GSL_f_pars_pt_Cosmology_set" "', argument " "2"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  if (arg1) (arg1)->pt_Cosmology = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GSL_f_pars_pt_Cosmology_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GSL_f_pars_pt_Cosmology_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSL_f_pars_pt_Cosmology_get" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  result = (cosmobl::Cosmology *) ((arg1)->pt_Cosmology);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GSL_f_pars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GSL_f_pars")) SWIG_fail;
  result = (cosmobl::glob::GSL_f_pars *)new cosmobl::glob::GSL_f_pars();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__GSL_f_pars, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GSL_f_pars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::GSL_f_pars *arg1 = (cosmobl::glob::GSL_f_pars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GSL_f_pars",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__GSL_f_pars, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GSL_f_pars" "', argument " "1"" of type '" "cosmobl::glob::GSL_f_pars *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::GSL_f_pars * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GSL_f_pars_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__GSL_f_pars, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_matter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_Omega_matter_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_matter_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_Omega_matter_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_matter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_matter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_Omega_matter_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_matter_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->Omega_matter);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_baryon_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_Omega_baryon_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_baryon_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_Omega_baryon_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_baryon = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_baryon_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_Omega_baryon_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_baryon_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->Omega_baryon);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_Omega_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_Omega_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_Omega_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->Omega_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_massless_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_massless_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_massless_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_massless_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->massless_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_massless_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_massless_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_massless_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->massless_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_massive_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_massive_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_massive_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_massive_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->massive_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_massive_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_massive_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_massive_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->massive_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_DE_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_Omega_DE_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_DE_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_Omega_DE_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_DE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_DE_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_Omega_DE_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_DE_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->Omega_DE);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_radiation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_Omega_radiation_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_radiation_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_Omega_radiation_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_radiation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_Omega_radiation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_Omega_radiation_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_Omega_radiation_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->Omega_radiation);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_hh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_hh_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_hh_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_hh_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->hh = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_hh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_hh_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_hh_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->hh);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_scalar_amp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_scalar_amp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_scalar_amp_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_scalar_amp_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->scalar_amp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_scalar_amp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_scalar_amp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_scalar_amp_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->scalar_amp);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_n_spec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_n_spec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_n_spec_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_n_spec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->n_spec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_n_spec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_n_spec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_n_spec_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->n_spec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_w0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_w0_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_w0_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_w0_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->w0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_w0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_w0_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_w0_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->w0);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_wa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_wa_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_wa_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_wa_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->wa = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_wa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_wa_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_wa_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->wa);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_fNL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_fNL_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_fNL_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_fNL_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->fNL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_fNL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_fNL_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_fNL_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->fNL);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_type_NG_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_type_NG_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_type_NG_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_type_NG_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->type_NG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_type_NG_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_type_NG_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_type_NG_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (int) ((arg1)->type_NG);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_model_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_model_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_model_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi_EH_model_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_xi_EH_model_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_model_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_model_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_model_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (std::string *) & ((arg1)->model);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_unit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_unit_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_unit_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_unit_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->unit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_unit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_unit_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_unit_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (bool) ((arg1)->unit);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_method_Pk_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_method_Pk_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_method_Pk_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi_EH_method_Pk_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_xi_EH_method_Pk_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->method_Pk = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_method_Pk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_method_Pk_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_method_Pk_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (std::string *) & ((arg1)->method_Pk);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_rr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_rr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_rr_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_rr_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->rr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_rr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_rr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_rr_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->rr);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_redshift_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_redshift_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_redshift_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_redshift_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->redshift = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_redshift_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_redshift_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_redshift_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->redshift);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_aa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi_EH_aa_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_aa_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi_EH_aa_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->aa = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi_EH_aa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi_EH_aa_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi_EH_aa_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  result = (double) ((arg1)->aa);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_xi_EH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_xi_EH")) SWIG_fail;
  result = (cosmobl::glob::STR_xi_EH *)new cosmobl::glob::STR_xi_EH();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_xi_EH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_xi_EH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi_EH *arg1 = (cosmobl::glob::STR_xi_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_xi_EH",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi_EH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_xi_EH" "', argument " "1"" of type '" "cosmobl::glob::STR_xi_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi_EH * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_xi_EH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_xi_EH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_matter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_Omega_matter_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_matter_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_Omega_matter_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_matter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_matter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_Omega_matter_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_matter_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->Omega_matter);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_baryon_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_Omega_baryon_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_baryon_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_Omega_baryon_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_baryon = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_baryon_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_Omega_baryon_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_baryon_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->Omega_baryon);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_Omega_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_Omega_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_Omega_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->Omega_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_massless_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_massless_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_massless_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_massless_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->massless_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_massless_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_massless_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_massless_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->massless_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_massive_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_massive_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_massive_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_massive_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->massive_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_massive_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_massive_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_massive_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->massive_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_DE_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_Omega_DE_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_DE_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_Omega_DE_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_DE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_DE_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_Omega_DE_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_DE_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->Omega_DE);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_radiation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_Omega_radiation_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_radiation_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_Omega_radiation_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_radiation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_Omega_radiation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_Omega_radiation_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_Omega_radiation_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->Omega_radiation);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_hh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_hh_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_hh_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_hh_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->hh = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_hh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_hh_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_hh_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->hh);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_scalar_amp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_scalar_amp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_scalar_amp_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_scalar_amp_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->scalar_amp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_scalar_amp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_scalar_amp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_scalar_amp_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->scalar_amp);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_n_spec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_n_spec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_n_spec_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_n_spec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->n_spec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_n_spec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_n_spec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_n_spec_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->n_spec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_w0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_w0_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_w0_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_w0_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->w0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_w0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_w0_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_w0_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->w0);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_wa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_wa_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_wa_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_wa_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->wa = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_wa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_wa_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_wa_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->wa);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_fNL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_fNL_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_fNL_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_fNL_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->fNL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_fNL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_fNL_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_fNL_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->fNL);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_type_NG_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_type_NG_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_type_NG_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_type_NG_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->type_NG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_type_NG_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_type_NG_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_type_NG_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (int) ((arg1)->type_NG);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_model_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_model_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_model_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_SSM_EH_model_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_SSM_EH_model_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_model_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_model_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_model_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (std::string *) & ((arg1)->model);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_unit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_unit_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_unit_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_unit_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->unit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_unit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_unit_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_unit_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (bool) ((arg1)->unit);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_method_Pk_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_method_Pk_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_method_Pk_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_SSM_EH_method_Pk_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_SSM_EH_method_Pk_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->method_Pk = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_method_Pk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_method_Pk_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_method_Pk_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (std::string *) & ((arg1)->method_Pk);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_redshift_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_redshift_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_redshift_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_redshift_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->redshift = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_redshift_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_redshift_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_redshift_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->redshift);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_mass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_mass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_mass_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_mass_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_mass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_mass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_mass_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->mass);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_rho_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_SSM_EH_rho_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_rho_set" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_SSM_EH_rho_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->rho = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_SSM_EH_rho_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_SSM_EH_rho_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_SSM_EH_rho_get" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  result = (double) ((arg1)->rho);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_SSM_EH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_SSM_EH")) SWIG_fail;
  result = (cosmobl::glob::STR_SSM_EH *)new cosmobl::glob::STR_SSM_EH();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_SSM_EH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_SSM_EH *arg1 = (cosmobl::glob::STR_SSM_EH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_SSM_EH",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_SSM_EH" "', argument " "1"" of type '" "cosmobl::glob::STR_SSM_EH *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_SSM_EH * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_SSM_EH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_SSM_EH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_NG_Omega_matter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_Omega_matter_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_matter_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_Omega_matter_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_matter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_matter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_Omega_matter_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_matter_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->Omega_matter);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_baryon_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_Omega_baryon_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_baryon_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_Omega_baryon_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_baryon = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_baryon_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_Omega_baryon_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_baryon_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->Omega_baryon);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_Omega_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_Omega_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_Omega_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->Omega_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_massless_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_massless_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_massless_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_massless_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->massless_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_massless_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_massless_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_massless_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->massless_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_massive_neutrinos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_massive_neutrinos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_massive_neutrinos_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_massive_neutrinos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->massive_neutrinos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_massive_neutrinos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_massive_neutrinos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_massive_neutrinos_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->massive_neutrinos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_DE_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_Omega_DE_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_DE_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_Omega_DE_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_DE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_DE_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_Omega_DE_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_DE_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->Omega_DE);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_radiation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_Omega_radiation_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_radiation_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_Omega_radiation_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Omega_radiation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_Omega_radiation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_Omega_radiation_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_Omega_radiation_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->Omega_radiation);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_hh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_hh_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_hh_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_hh_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->hh = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_hh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_hh_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_hh_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->hh);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_scalar_amp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_scalar_amp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_scalar_amp_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_scalar_amp_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->scalar_amp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_scalar_amp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_scalar_amp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_scalar_amp_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->scalar_amp);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_n_spec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_n_spec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_n_spec_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_n_spec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->n_spec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_n_spec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_n_spec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_n_spec_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->n_spec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_w0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_w0_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_w0_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_w0_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->w0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_w0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_w0_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_w0_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->w0);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_wa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_wa_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_wa_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_wa_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->wa = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_wa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_wa_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_wa_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->wa);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_fNL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_fNL_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_fNL_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_fNL_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->fNL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_fNL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_fNL_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_fNL_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->fNL);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_type_NG_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_type_NG_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_type_NG_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_type_NG_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->type_NG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_type_NG_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_type_NG_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_type_NG_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (int) ((arg1)->type_NG);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_model_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_model_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_model_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_NG_model_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_NG_model_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_model_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_model_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_model_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (std::string *) & ((arg1)->model);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_unit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_unit_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_unit_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_unit_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->unit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_unit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_unit_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_unit_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (bool) ((arg1)->unit);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_kt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_kt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_kt_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_kt_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->kt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_kt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_kt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_kt_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->kt);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_mass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_mass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_mass_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_mass_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_mass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_mass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_mass_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->mass);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_method_Pk_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_method_Pk_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_method_Pk_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_NG_method_Pk_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_NG_method_Pk_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->method_Pk = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_method_Pk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_method_Pk_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_method_Pk_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (std::string *) & ((arg1)->method_Pk);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_output_root_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_output_root_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_output_root_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_NG_output_root_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_NG_output_root_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->output_root = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_output_root_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_output_root_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_output_root_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (std::string *) & ((arg1)->output_root);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_norm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_norm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_norm_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_norm_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->norm = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_norm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_norm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_norm_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (int) ((arg1)->norm);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_k_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_k_min_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_k_min_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_k_min_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->k_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_k_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_k_min_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_k_min_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->k_min);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_k_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_k_max_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_k_max_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_k_max_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->k_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_k_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_k_max_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_k_max_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->k_max);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_GSL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_GSL_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_GSL_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_GSL_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->GSL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_GSL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_GSL_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_GSL_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (bool) ((arg1)->GSL);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_prec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_prec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_prec_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_NG_prec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->prec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_prec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_prec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_prec_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (double) ((arg1)->prec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_file_par_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_NG_file_par_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_file_par_set" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_NG_file_par_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_NG_file_par_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->file_par = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_NG_file_par_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_NG_file_par_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_NG_file_par_get" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  result = (std::string *) & ((arg1)->file_par);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_NG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_NG")) SWIG_fail;
  result = (cosmobl::glob::STR_NG *)new cosmobl::glob::STR_NG();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_NG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_NG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_NG *arg1 = (cosmobl::glob::STR_NG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_NG",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_NG, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_NG" "', argument " "1"" of type '" "cosmobl::glob::STR_NG *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_NG * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_NG_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_NG, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ChainMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ChainMesh")) SWIG_fail;
  result = (cosmobl::ChainMesh *)new cosmobl::ChainMesh();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ChainMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainMesh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainMesh" "', argument " "1"" of type '" "cosmobl::ChainMesh *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_set_par(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  double arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ChainMesh_set_par",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_long(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ChainMesh_set_par" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->set_par(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  long arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::ChainMesh *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ChainMesh",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainMesh" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  result = (cosmobl::ChainMesh *)new cosmobl::ChainMesh(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ChainMesh__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ChainMesh__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ChainMesh'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh::ChainMesh()\n"
    "    cosmobl::ChainMesh::ChainMesh(double const,long const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ChainMesh_nCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ChainMesh_nCell",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_nCell" "', argument " "1"" of type '" "cosmobl::ChainMesh const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  result = (long)((cosmobl::ChainMesh const *)arg1)->nCell();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_pos_to_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ChainMesh_pos_to_index",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_pos_to_index" "', argument " "1"" of type '" "cosmobl::ChainMesh const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_pos_to_index" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_pos_to_index" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (long)((cosmobl::ChainMesh const *)arg1)->pos_to_index(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_inds_to_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  SwigValueWrapper< std::vector< long > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ChainMesh_inds_to_index",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_inds_to_index" "', argument " "1"" of type '" "cosmobl::ChainMesh const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_inds_to_index" "', argument " "2"" of type '" "std::vector< long > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_inds_to_index" "', argument " "2"" of type '" "std::vector< long > const""'");
    } else {
      std::vector< long > * temp = reinterpret_cast< std::vector< long > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (long)((cosmobl::ChainMesh const *)arg1)->inds_to_index(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_index_to_inds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  long arg2 ;
  SwigValueWrapper< std::vector< long > > arg3 ;
  std::vector< long > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ChainMesh_index_to_inds",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_index_to_inds" "', argument " "1"" of type '" "cosmobl::ChainMesh const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh_index_to_inds" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh_index_to_inds" "', argument " "3"" of type '" "std::vector< long > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_index_to_inds" "', argument " "3"" of type '" "std::vector< long > const""'");
    } else {
      std::vector< long > * temp = reinterpret_cast< std::vector< long > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ChainMesh_index_to_inds" "', argument " "4"" of type '" "std::vector< long > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_index_to_inds" "', argument " "4"" of type '" "std::vector< long > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< long > * >(argp4);
  ((cosmobl::ChainMesh const *)arg1)->index_to_inds(arg2,arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_create_chain_mesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg2 ;
  double arg3 ;
  long arg4 ;
  long arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ChainMesh_create_chain_mesh",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_create_chain_mesh" "', argument " "1"" of type '" "cosmobl::ChainMesh *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_create_chain_mesh" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_create_chain_mesh" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ChainMesh_create_chain_mesh" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_long(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ChainMesh_create_chain_mesh" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  ecode5 = SWIG_AsVal_long(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ChainMesh_create_chain_mesh" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  (arg1)->create_chain_mesh(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_create_chain_mesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg2 ;
  double arg3 ;
  long arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ChainMesh_create_chain_mesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_create_chain_mesh" "', argument " "1"" of type '" "cosmobl::ChainMesh *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_create_chain_mesh" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_create_chain_mesh" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ChainMesh_create_chain_mesh" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_long(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ChainMesh_create_chain_mesh" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  (arg1)->create_chain_mesh(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_create_chain_mesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ChainMesh_create_chain_mesh",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_create_chain_mesh" "', argument " "1"" of type '" "cosmobl::ChainMesh *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_create_chain_mesh" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_create_chain_mesh" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ChainMesh_create_chain_mesh" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->create_chain_mesh(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_create_chain_mesh(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ChainMesh_create_chain_mesh__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ChainMesh_create_chain_mesh__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ChainMesh_create_chain_mesh__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ChainMesh_create_chain_mesh'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh::create_chain_mesh(std::vector< std::vector< double,std::allocator< double > > > const,double const,long const,long const)\n"
    "    cosmobl::ChainMesh::create_chain_mesh(std::vector< std::vector< double,std::allocator< double > > > const,double const,long const)\n"
    "    cosmobl::ChainMesh::create_chain_mesh(std::vector< std::vector< double,std::allocator< double > > > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ChainMesh_create_chain_mesh_m2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ChainMesh_create_chain_mesh_m2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_create_chain_mesh_m2" "', argument " "1"" of type '" "cosmobl::ChainMesh *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_create_chain_mesh_m2" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_create_chain_mesh_m2" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->create_chain_mesh_m2(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_get_searching_region__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ChainMesh_get_searching_region",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_get_searching_region" "', argument " "1"" of type '" "cosmobl::ChainMesh *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh_get_searching_region" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ChainMesh_get_searching_region" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->get_searching_region(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_get_searching_region__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ChainMesh_get_searching_region",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_get_searching_region" "', argument " "1"" of type '" "cosmobl::ChainMesh *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh_get_searching_region" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->get_searching_region(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_get_searching_region(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ChainMesh_get_searching_region__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ChainMesh_get_searching_region__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ChainMesh_get_searching_region'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh::get_searching_region(double const,double const)\n"
    "    cosmobl::ChainMesh::get_searching_region(double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ChainMesh_close_objects__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigValueWrapper< std::vector< long > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ChainMesh_close_objects",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_close_objects" "', argument " "1"" of type '" "cosmobl::ChainMesh const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_close_objects" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_close_objects" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_long(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ChainMesh_close_objects" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  result = ((cosmobl::ChainMesh const *)arg1)->close_objects(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::vector< long >(static_cast< const std::vector< long >& >(result))), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_close_objects__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::vector< long > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ChainMesh_close_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_close_objects" "', argument " "1"" of type '" "cosmobl::ChainMesh const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_close_objects" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_close_objects" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = ((cosmobl::ChainMesh const *)arg1)->close_objects(arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< long >(static_cast< const std::vector< long >& >(result))), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_close_objects(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ChainMesh_close_objects__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ChainMesh_close_objects__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ChainMesh_close_objects'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh::close_objects(std::vector< double >,long) const\n"
    "    cosmobl::ChainMesh::close_objects(std::vector< double >) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ChainMesh_get_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh *arg1 = (cosmobl::ChainMesh *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::vector< long > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ChainMesh_get_list",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_get_list" "', argument " "1"" of type '" "cosmobl::ChainMesh const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh_get_list" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  result = ((cosmobl::ChainMesh const *)arg1)->get_list(arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< long >(static_cast< const std::vector< long >& >(result))), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ChainMesh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__ChainMesh, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ChainMesh1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh1D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ChainMesh1D")) SWIG_fail;
  result = (cosmobl::ChainMesh1D *)new cosmobl::ChainMesh1D();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh1D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ChainMesh1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh1D *arg1 = (cosmobl::ChainMesh1D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainMesh1D",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh1D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainMesh1D" "', argument " "1"" of type '" "cosmobl::ChainMesh1D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh1D * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh1D_set_par__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh1D *arg1 = (cosmobl::ChainMesh1D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  long arg5 ;
  long arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ChainMesh1D_set_par",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh1D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh1D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh1D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh1D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh1D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh1D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh1D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ChainMesh1D_set_par" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_long(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ChainMesh1D_set_par" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  ecode6 = SWIG_AsVal_long(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ChainMesh1D_set_par" "', argument " "6"" of type '" "long""'");
  } 
  arg6 = static_cast< long >(val6);
  (arg1)->set_par(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh1D_set_par__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh1D *arg1 = (cosmobl::ChainMesh1D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  long arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ChainMesh1D_set_par",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh1D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh1D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh1D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh1D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh1D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh1D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh1D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ChainMesh1D_set_par" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_long(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ChainMesh1D_set_par" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  (arg1)->set_par(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh1D_set_par__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh1D *arg1 = (cosmobl::ChainMesh1D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ChainMesh1D_set_par",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh1D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh1D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh1D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh1D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh1D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh1D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh1D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ChainMesh1D_set_par" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_par(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh1D_set_par(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh1D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ChainMesh1D_set_par__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh1D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ChainMesh1D_set_par__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh1D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_long(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ChainMesh1D_set_par__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ChainMesh1D_set_par'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh1D::set_par(double const,std::vector< double > const,double const,long const,long const)\n"
    "    cosmobl::ChainMesh1D::set_par(double const,std::vector< double > const,double const,long const)\n"
    "    cosmobl::ChainMesh1D::set_par(double const,std::vector< double > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  double arg3 ;
  long arg4 ;
  long arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::ChainMesh1D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ChainMesh1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh1D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh1D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh1D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainMesh1D" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_long(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainMesh1D" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  ecode5 = SWIG_AsVal_long(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainMesh1D" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  result = (cosmobl::ChainMesh1D *)new cosmobl::ChainMesh1D(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh1D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh1D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  double arg3 ;
  long arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::ChainMesh1D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ChainMesh1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh1D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh1D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh1D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainMesh1D" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_long(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainMesh1D" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  result = (cosmobl::ChainMesh1D *)new cosmobl::ChainMesh1D(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh1D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh1D__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::ChainMesh1D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ChainMesh1D",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh1D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh1D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh1D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainMesh1D" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::ChainMesh1D *)new cosmobl::ChainMesh1D(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh1D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh1D(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ChainMesh1D__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ChainMesh1D__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ChainMesh1D__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ChainMesh1D__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ChainMesh1D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh1D::ChainMesh1D()\n"
    "    cosmobl::ChainMesh1D::ChainMesh1D(double const,std::vector< double > const,double const,long const,long const)\n"
    "    cosmobl::ChainMesh1D::ChainMesh1D(double const,std::vector< double > const,double const,long const)\n"
    "    cosmobl::ChainMesh1D::ChainMesh1D(double const,std::vector< double > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *ChainMesh1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__ChainMesh1D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ChainMesh2D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ChainMesh2D")) SWIG_fail;
  result = (cosmobl::ChainMesh2D *)new cosmobl::ChainMesh2D();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ChainMesh2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh2D *arg1 = (cosmobl::ChainMesh2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainMesh2D",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainMesh2D" "', argument " "1"" of type '" "cosmobl::ChainMesh2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh2D * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh2D_set_par__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh2D *arg1 = (cosmobl::ChainMesh2D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double arg5 ;
  long arg6 ;
  long arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ChainMesh2D_set_par",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh2D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh2D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh2D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh2D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ChainMesh2D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh2D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ChainMesh2D_set_par" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_long(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ChainMesh2D_set_par" "', argument " "6"" of type '" "long""'");
  } 
  arg6 = static_cast< long >(val6);
  ecode7 = SWIG_AsVal_long(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ChainMesh2D_set_par" "', argument " "7"" of type '" "long""'");
  } 
  arg7 = static_cast< long >(val7);
  (arg1)->set_par(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh2D_set_par__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh2D *arg1 = (cosmobl::ChainMesh2D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double arg5 ;
  long arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ChainMesh2D_set_par",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh2D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh2D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh2D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh2D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ChainMesh2D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh2D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ChainMesh2D_set_par" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_long(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ChainMesh2D_set_par" "', argument " "6"" of type '" "long""'");
  } 
  arg6 = static_cast< long >(val6);
  (arg1)->set_par(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh2D_set_par__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh2D *arg1 = (cosmobl::ChainMesh2D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ChainMesh2D_set_par",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh2D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh2D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh2D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh2D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ChainMesh2D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh2D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ChainMesh2D_set_par" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->set_par(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh2D_set_par(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ChainMesh2D_set_par__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_long(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ChainMesh2D_set_par__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_long(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_long(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ChainMesh2D_set_par__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ChainMesh2D_set_par'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh2D::set_par(double const,std::vector< double > const,std::vector< double > const,double const,long const,long const)\n"
    "    cosmobl::ChainMesh2D::set_par(double const,std::vector< double > const,std::vector< double > const,double const,long const)\n"
    "    cosmobl::ChainMesh2D::set_par(double const,std::vector< double > const,std::vector< double > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh2D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  long arg5 ;
  long arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::ChainMesh2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_ChainMesh2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh2D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh2D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh2D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainMesh2D" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh2D" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainMesh2D" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_long(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainMesh2D" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  ecode6 = SWIG_AsVal_long(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ChainMesh2D" "', argument " "6"" of type '" "long""'");
  } 
  arg6 = static_cast< long >(val6);
  result = (cosmobl::ChainMesh2D *)new cosmobl::ChainMesh2D(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh2D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  long arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::ChainMesh2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ChainMesh2D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh2D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh2D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh2D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainMesh2D" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh2D" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainMesh2D" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_long(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainMesh2D" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  result = (cosmobl::ChainMesh2D *)new cosmobl::ChainMesh2D(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh2D__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::ChainMesh2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ChainMesh2D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh2D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh2D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh2D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainMesh2D" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh2D" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainMesh2D" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (cosmobl::ChainMesh2D *)new cosmobl::ChainMesh2D(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh2D(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ChainMesh2D__SWIG_0(self, args);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ChainMesh2D__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ChainMesh2D__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_long(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ChainMesh2D__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ChainMesh2D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh2D::ChainMesh2D()\n"
    "    cosmobl::ChainMesh2D::ChainMesh2D(double const,std::vector< double > const,std::vector< double > const,double const,long const,long const)\n"
    "    cosmobl::ChainMesh2D::ChainMesh2D(double const,std::vector< double > const,std::vector< double > const,double const,long const)\n"
    "    cosmobl::ChainMesh2D::ChainMesh2D(double const,std::vector< double > const,std::vector< double > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *ChainMesh2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__ChainMesh2D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ChainMesh3D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh3D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ChainMesh3D")) SWIG_fail;
  result = (cosmobl::ChainMesh3D *)new cosmobl::ChainMesh3D();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ChainMesh3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh3D *arg1 = (cosmobl::ChainMesh3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainMesh3D",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainMesh3D" "', argument " "1"" of type '" "cosmobl::ChainMesh3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh3D * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh3D_set_par__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh3D *arg1 = (cosmobl::ChainMesh3D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  double arg6 ;
  long arg7 ;
  long arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ChainMesh3D_set_par",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh3D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh3D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh3D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ChainMesh3D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ChainMesh3D_set_par" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ChainMesh3D_set_par" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_long(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ChainMesh3D_set_par" "', argument " "7"" of type '" "long""'");
  } 
  arg7 = static_cast< long >(val7);
  ecode8 = SWIG_AsVal_long(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ChainMesh3D_set_par" "', argument " "8"" of type '" "long""'");
  } 
  arg8 = static_cast< long >(val8);
  (arg1)->set_par(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh3D_set_par__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh3D *arg1 = (cosmobl::ChainMesh3D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  double arg6 ;
  long arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ChainMesh3D_set_par",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh3D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh3D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh3D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ChainMesh3D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ChainMesh3D_set_par" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ChainMesh3D_set_par" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_long(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ChainMesh3D_set_par" "', argument " "7"" of type '" "long""'");
  } 
  arg7 = static_cast< long >(val7);
  (arg1)->set_par(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh3D_set_par__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh3D *arg1 = (cosmobl::ChainMesh3D *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ChainMesh3D_set_par",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh3D_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh3D_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh3D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ChainMesh3D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ChainMesh3D_set_par" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh3D_set_par" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ChainMesh3D_set_par" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  (arg1)->set_par(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh3D_set_par(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ChainMesh3D_set_par__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_long(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ChainMesh3D_set_par__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_long(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_long(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ChainMesh3D_set_par__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ChainMesh3D_set_par'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh3D::set_par(double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,long const,long const)\n"
    "    cosmobl::ChainMesh3D::set_par(double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,long const)\n"
    "    cosmobl::ChainMesh3D::set_par(double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh3D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double arg5 ;
  long arg6 ;
  long arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::ChainMesh3D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_ChainMesh3D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh3D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh3D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainMesh3D" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ChainMesh3D" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainMesh3D" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_long(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ChainMesh3D" "', argument " "6"" of type '" "long""'");
  } 
  arg6 = static_cast< long >(val6);
  ecode7 = SWIG_AsVal_long(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ChainMesh3D" "', argument " "7"" of type '" "long""'");
  } 
  arg7 = static_cast< long >(val7);
  result = (cosmobl::ChainMesh3D *)new cosmobl::ChainMesh3D(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh3D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double arg5 ;
  long arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::ChainMesh3D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_ChainMesh3D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh3D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh3D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainMesh3D" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ChainMesh3D" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainMesh3D" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_long(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ChainMesh3D" "', argument " "6"" of type '" "long""'");
  } 
  arg6 = static_cast< long >(val6);
  result = (cosmobl::ChainMesh3D *)new cosmobl::ChainMesh3D(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh3D__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::ChainMesh3D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ChainMesh3D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh3D" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh3D" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainMesh3D" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ChainMesh3D" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh3D" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainMesh3D" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::ChainMesh3D *)new cosmobl::ChainMesh3D(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh3D(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ChainMesh3D__SWIG_0(self, args);
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ChainMesh3D__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_long(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ChainMesh3D__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_long(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_long(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ChainMesh3D__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ChainMesh3D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh3D::ChainMesh3D()\n"
    "    cosmobl::ChainMesh3D::ChainMesh3D(double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,long const,long const)\n"
    "    cosmobl::ChainMesh3D::ChainMesh3D(double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,long const)\n"
    "    cosmobl::ChainMesh3D::ChainMesh3D(double const,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *ChainMesh3D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__ChainMesh3D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Object(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Object")) SWIG_fail;
  result = (cosmobl::Object *)new cosmobl::Object();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Object, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Object(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Object",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Object" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_make_Object__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  std::shared_ptr< cosmobl::Object > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Object_make_Object",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Object_make_Object" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_make_Object" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Object_make_Object" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Object_make_Object" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Object_make_Object" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = cosmobl::Object::make_Object(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Object >(static_cast< const std::shared_ptr< cosmobl::Object >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_make_Object__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::shared_ptr< cosmobl::Object > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Object_make_Object",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Object_make_Object" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_make_Object" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Object_make_Object" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Object_make_Object" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = cosmobl::Object::make_Object(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Object >(static_cast< const std::shared_ptr< cosmobl::Object >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_make_Object__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double arg6 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  std::shared_ptr< cosmobl::Object > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Object_make_Object",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Object_make_Object" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_make_Object" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Object_make_Object" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Object_make_Object" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Object_make_Object" "', argument " "5"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_make_Object" "', argument " "5"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Object_make_Object" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = cosmobl::Object::make_Object(arg1,arg2,arg3,arg4,(cosmobl::Cosmology const &)*arg5,arg6);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Object >(static_cast< const std::shared_ptr< cosmobl::Object >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_make_Object__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  std::shared_ptr< cosmobl::Object > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Object_make_Object",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Object_make_Object" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_make_Object" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Object_make_Object" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Object_make_Object" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Object_make_Object" "', argument " "5"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_make_Object" "', argument " "5"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  result = cosmobl::Object::make_Object(arg1,arg2,arg3,arg4,(cosmobl::Cosmology const &)*arg5);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Object >(static_cast< const std::shared_ptr< cosmobl::Object >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_make_Object(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Object_make_Object__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Object_make_Object__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Object_make_Object__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Object_make_Object__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Object_make_Object'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Object::make_Object(std::string,double,double,double,double)\n"
    "    cosmobl::Object::make_Object(std::string,double,double,double)\n"
    "    cosmobl::Object::make_Object(std::string,double,double,double,cosmobl::Cosmology const &,double)\n"
    "    cosmobl::Object::make_Object(std::string,double,double,double,cosmobl::Cosmology const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Object_xx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_xx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_xx" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->xx();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_yy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_yy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_yy" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->yy();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_zz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_zz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_zz" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->zz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_vx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_vx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_vx" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->vx();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_vy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_vy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_vy" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->vy();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_vz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_vz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_vz" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->vz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_dc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_dc" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->dc();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_ra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_ra",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_ra" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->ra();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_dec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_dec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_dec" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->dec();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_redshift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_redshift",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_redshift" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->redshift();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_weight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_weight" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->weight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_region",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_region" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (long)((cosmobl::Object const *)arg1)->region();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_mass" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->mass();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_magnitude(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_magnitude",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_magnitude" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->magnitude();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_richness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_richness",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_richness" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->richness();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_generic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_generic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_generic" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->generic();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_radius(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_radius",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_radius" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = (double)((cosmobl::Object const *)arg1)->radius();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_coords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Object_coords",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_coords" "', argument " "1"" of type '" "cosmobl::Object const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  result = ((cosmobl::Object const *)arg1)->coords();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_xx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_xx",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_xx" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_xx" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_xx(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_yy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_yy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_yy" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_yy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_yy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_zz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_zz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_zz" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_zz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_zz(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_vx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_vx",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_vx" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_vx" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_vx(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_vy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_vy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_vy" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_vy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_vy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_vz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_vz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_vz" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_vz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_vz(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_dc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_dc" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_dc" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_dc(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_ra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_ra",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_ra" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_ra" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_ra(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_dec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_dec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_dec" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_dec" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_dec(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_redshift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_redshift",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_redshift" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_redshift" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_redshift(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_weight" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_weight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_region",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_region" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_region" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->set_region(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_mass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_mass" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_mass" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_mass(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_magnitude(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_magnitude",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_magnitude" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_magnitude" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_magnitude(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_richness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_richness",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_richness" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_richness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_richness(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_generic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_generic",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_generic" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_generic" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_generic(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Object_set_radius(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Object *arg1 = (cosmobl::Object *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Object_set_radius",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_set_radius" "', argument " "1"" of type '" "cosmobl::Object *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Object * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Object_set_radius" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_radius(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Object, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GenericObject")) SWIG_fail;
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_GenericObject",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GenericObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GenericObject" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_GenericObject",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GenericObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_GenericObject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GenericObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GenericObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GenericObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GenericObject" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GenericObject" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_GenericObject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GenericObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GenericObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GenericObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GenericObject" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_GenericObject",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GenericObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GenericObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GenericObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_GenericObject",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GenericObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GenericObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_GenericObject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GenericObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GenericObject" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GenericObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GenericObject" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GenericObject" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::GenericObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_GenericObject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GenericObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GenericObject" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GenericObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GenericObject" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::GenericObject *)new cosmobl::GenericObject(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObject(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_GenericObject__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_GenericObject__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_GenericObject__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GenericObject__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_GenericObject__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_GenericObject__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_GenericObject__SWIG_8(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_GenericObject__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_GenericObject__SWIG_7(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GenericObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::GenericObject::GenericObject()\n"
    "    cosmobl::GenericObject::GenericObject(double const,double const,double const,double const)\n"
    "    cosmobl::GenericObject::GenericObject(double const,double const,double const)\n"
    "    cosmobl::GenericObject::GenericObject(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const)\n"
    "    cosmobl::GenericObject::GenericObject(double const,double const,double const,cosmobl::Cosmology const &,double const,double const)\n"
    "    cosmobl::GenericObject::GenericObject(double const,double const,double const,cosmobl::Cosmology const &,double const)\n"
    "    cosmobl::GenericObject::GenericObject(double const,double const,double const,cosmobl::Cosmology const &)\n"
    "    cosmobl::GenericObject::GenericObject(double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::GenericObject::GenericObject(double const,double const,double const,double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GenericObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GenericObject",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenericObject" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_xx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_xx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_xx" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (double)((cosmobl::GenericObject const *)arg1)->xx();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_yy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_yy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_yy" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (double)((cosmobl::GenericObject const *)arg1)->yy();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_zz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_zz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_zz" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (double)((cosmobl::GenericObject const *)arg1)->zz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_dc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_dc" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (double)((cosmobl::GenericObject const *)arg1)->dc();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_ra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_ra",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_ra" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (double)((cosmobl::GenericObject const *)arg1)->ra();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_dec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_dec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_dec" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (double)((cosmobl::GenericObject const *)arg1)->dec();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_redshift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_redshift",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_redshift" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (double)((cosmobl::GenericObject const *)arg1)->redshift();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_weight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_weight" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (double)((cosmobl::GenericObject const *)arg1)->weight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_region",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_region" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = (long)((cosmobl::GenericObject const *)arg1)->region();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_coords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObject_coords",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_coords" "', argument " "1"" of type '" "cosmobl::GenericObject const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  result = ((cosmobl::GenericObject const *)arg1)->coords();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_xx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_xx",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_xx" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_xx" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_xx(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_yy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_yy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_yy" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_yy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_yy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_zz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_zz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_zz" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_zz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_zz(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_ra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_ra",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_ra" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_ra" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_ra(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_dec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_dec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_dec" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_dec" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_dec(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_redshift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_redshift",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_redshift" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_redshift" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_redshift(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_dc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_dc" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_dc" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_dc(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_weight" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_weight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObject_set_region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::GenericObject *arg1 = (cosmobl::GenericObject *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObject_set_region",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObject_set_region" "', argument " "1"" of type '" "cosmobl::GenericObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::GenericObject * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObject_set_region" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->set_region(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GenericObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__GenericObject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RandomObject")) SWIG_fail;
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_RandomObject",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RandomObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RandomObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RandomObject" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_RandomObject",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RandomObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RandomObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_RandomObject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RandomObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RandomObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RandomObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RandomObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RandomObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RandomObject" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RandomObject" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_RandomObject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RandomObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RandomObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RandomObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RandomObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RandomObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RandomObject" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_RandomObject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RandomObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RandomObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RandomObject" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RandomObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RandomObject" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RandomObject" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_RandomObject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RandomObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RandomObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RandomObject" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RandomObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RandomObject" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_RandomObject",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RandomObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RandomObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RandomObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RandomObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RandomObject" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::RandomObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_RandomObject",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObject" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RandomObject" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RandomObject" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RandomObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RandomObject" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  result = (cosmobl::RandomObject *)new cosmobl::RandomObject(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObject(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_RandomObject__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RandomObject__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_RandomObject__SWIG_8(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_RandomObject__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_RandomObject__SWIG_7(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_RandomObject__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_RandomObject__SWIG_6(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_RandomObject__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_RandomObject__SWIG_5(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RandomObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::RandomObject::RandomObject()\n"
    "    cosmobl::RandomObject::RandomObject(double const,double const,double const,double const)\n"
    "    cosmobl::RandomObject::RandomObject(double const,double const,double const)\n"
    "    cosmobl::RandomObject::RandomObject(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const)\n"
    "    cosmobl::RandomObject::RandomObject(double const,double const,double const,cosmobl::Cosmology const &,double const,double const)\n"
    "    cosmobl::RandomObject::RandomObject(double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::RandomObject::RandomObject(double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::RandomObject::RandomObject(double const,double const,double const,cosmobl::Cosmology const &,double const)\n"
    "    cosmobl::RandomObject::RandomObject(double const,double const,double const,cosmobl::Cosmology const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RandomObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::RandomObject *arg1 = (cosmobl::RandomObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RandomObject",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RandomObject" "', argument " "1"" of type '" "cosmobl::RandomObject *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::RandomObject * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RandomObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__RandomObject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Halo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Halo")) SWIG_fail;
  result = (cosmobl::Halo *)new cosmobl::Halo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Halo" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Halo" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Halo" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Halo",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Halo" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Halo",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Halo" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Halo" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Halo" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Halo" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Halo" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Halo" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Halo" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Halo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Halo" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Halo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Halo",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Halo" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Halo" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Halo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Halo" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  result = (cosmobl::Halo *)new cosmobl::Halo(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Halo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Halo__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Halo__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Halo__SWIG_12(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Halo__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Halo__SWIG_11(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Halo__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Halo__SWIG_10(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Halo__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Halo__SWIG_9(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Halo__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Halo__SWIG_8(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Halo__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Halo__SWIG_7(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Halo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Halo::Halo()\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,cosmobl::Cosmology const &,double const,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,cosmobl::Cosmology const &,double const)\n"
    "    cosmobl::Halo::Halo(double const,double const,double const,cosmobl::Cosmology const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Halo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Halo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Halo" "', argument " "1"" of type '" "cosmobl::Halo *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Halo_vx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Halo_vx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Halo_vx" "', argument " "1"" of type '" "cosmobl::Halo const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  result = (double)((cosmobl::Halo const *)arg1)->vx();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Halo_vy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Halo_vy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Halo_vy" "', argument " "1"" of type '" "cosmobl::Halo const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  result = (double)((cosmobl::Halo const *)arg1)->vy();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Halo_vz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Halo_vz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Halo_vz" "', argument " "1"" of type '" "cosmobl::Halo const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  result = (double)((cosmobl::Halo const *)arg1)->vz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Halo_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Halo_mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Halo_mass" "', argument " "1"" of type '" "cosmobl::Halo const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  result = (double)((cosmobl::Halo const *)arg1)->mass();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Halo_set_vx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Halo_set_vx",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Halo_set_vx" "', argument " "1"" of type '" "cosmobl::Halo *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Halo_set_vx" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_vx(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Halo_set_vy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Halo_set_vy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Halo_set_vy" "', argument " "1"" of type '" "cosmobl::Halo *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Halo_set_vy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_vy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Halo_set_vz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Halo_set_vz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Halo_set_vz" "', argument " "1"" of type '" "cosmobl::Halo *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Halo_set_vz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_vz(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Halo_set_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Halo *arg1 = (cosmobl::Halo *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Halo_set_mass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Halo_set_mass" "', argument " "1"" of type '" "cosmobl::Halo *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Halo * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Halo_set_mass" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_mass(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Halo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Halo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Mock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Mock")) SWIG_fail;
  result = (cosmobl::Mock *)new cosmobl::Mock();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mock" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mock" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mock" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Mock" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mock" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mock" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mock" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mock" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mock" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mock" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mock" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mock",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mock" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Mock",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mock" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mock" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Mock" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Mock" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mock" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mock" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Mock" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mock" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mock" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mock" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mock" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Mock",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mock" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Mock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mock",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mock" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mock" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mock" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  result = (cosmobl::Mock *)new cosmobl::Mock(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mock(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[11] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Mock__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Mock__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Mock__SWIG_14(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Mock__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Mock__SWIG_13(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Mock__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Mock__SWIG_12(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Mock__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Mock__SWIG_11(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Mock__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Mock__SWIG_10(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Mock__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Mock__SWIG_9(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Mock__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_Mock__SWIG_8(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Mock'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Mock::Mock()\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,cosmobl::Cosmology const &,double const,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,cosmobl::Cosmology const &,double const)\n"
    "    cosmobl::Mock::Mock(double const,double const,double const,cosmobl::Cosmology const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Mock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Mock *arg1 = (cosmobl::Mock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Mock",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mock" "', argument " "1"" of type '" "cosmobl::Mock *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Mock * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mock_generic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Mock *arg1 = (cosmobl::Mock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mock_generic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Mock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mock_generic" "', argument " "1"" of type '" "cosmobl::Mock const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Mock * >(argp1);
  result = (double)((cosmobl::Mock const *)arg1)->generic();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mock_set_generic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Mock *arg1 = (cosmobl::Mock *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mock_set_generic",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Mock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mock_set_generic" "', argument " "1"" of type '" "cosmobl::Mock *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Mock * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mock_set_generic" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_generic(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Mock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Mock, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Galaxy")) SWIG_fail;
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Galaxy",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Galaxy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Galaxy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Galaxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Galaxy" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Galaxy" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Galaxy" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Galaxy",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Galaxy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Galaxy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Galaxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Galaxy" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Galaxy" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Galaxy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Galaxy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Galaxy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Galaxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Galaxy" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Galaxy",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Galaxy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Galaxy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Galaxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Galaxy",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Galaxy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Galaxy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Galaxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Galaxy" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Galaxy" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Galaxy" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Galaxy" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Galaxy" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Galaxy",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Galaxy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Galaxy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Galaxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Galaxy" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Galaxy" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Galaxy" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Galaxy" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Galaxy",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Galaxy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Galaxy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Galaxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Galaxy" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Galaxy" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Galaxy" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Galaxy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Galaxy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Galaxy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Galaxy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Galaxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Galaxy" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Galaxy" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  result = (cosmobl::Galaxy *)new cosmobl::Galaxy(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Galaxy(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Galaxy__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Galaxy__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Galaxy__SWIG_8(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Galaxy__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Galaxy__SWIG_7(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Galaxy__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Galaxy__SWIG_6(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Galaxy__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Galaxy__SWIG_5(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Galaxy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Galaxy::Galaxy()\n"
    "    cosmobl::Galaxy::Galaxy(double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Galaxy::Galaxy(double const,double const,double const,double const,double const)\n"
    "    cosmobl::Galaxy::Galaxy(double const,double const,double const,double const)\n"
    "    cosmobl::Galaxy::Galaxy(double const,double const,double const)\n"
    "    cosmobl::Galaxy::Galaxy(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const)\n"
    "    cosmobl::Galaxy::Galaxy(double const,double const,double const,cosmobl::Cosmology const &,double const,double const)\n"
    "    cosmobl::Galaxy::Galaxy(double const,double const,double const,cosmobl::Cosmology const &,double const)\n"
    "    cosmobl::Galaxy::Galaxy(double const,double const,double const,cosmobl::Cosmology const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Galaxy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Galaxy *arg1 = (cosmobl::Galaxy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Galaxy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Galaxy" "', argument " "1"" of type '" "cosmobl::Galaxy *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Galaxy * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Galaxy_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Galaxy *arg1 = (cosmobl::Galaxy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Galaxy_mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Galaxy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Galaxy_mass" "', argument " "1"" of type '" "cosmobl::Galaxy const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Galaxy * >(argp1);
  result = (double)((cosmobl::Galaxy const *)arg1)->mass();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Galaxy_magnitude(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Galaxy *arg1 = (cosmobl::Galaxy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Galaxy_magnitude",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Galaxy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Galaxy_magnitude" "', argument " "1"" of type '" "cosmobl::Galaxy const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Galaxy * >(argp1);
  result = (double)((cosmobl::Galaxy const *)arg1)->magnitude();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Galaxy_set_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Galaxy *arg1 = (cosmobl::Galaxy *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Galaxy_set_mass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Galaxy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Galaxy_set_mass" "', argument " "1"" of type '" "cosmobl::Galaxy *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Galaxy * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Galaxy_set_mass" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_mass(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Galaxy_set_magnitude(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Galaxy *arg1 = (cosmobl::Galaxy *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Galaxy_set_magnitude",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Galaxy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Galaxy_set_magnitude" "', argument " "1"" of type '" "cosmobl::Galaxy *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Galaxy * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Galaxy_set_magnitude" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_magnitude(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Galaxy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Galaxy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Cluster")) SWIG_fail;
  result = (cosmobl::Cluster *)new cosmobl::Cluster();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Cluster",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cluster" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cluster" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cluster" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cluster" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cluster" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cluster" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Cluster *)new cosmobl::Cluster(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Cluster",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cluster" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cluster" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cluster" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cluster" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cluster" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Cluster *)new cosmobl::Cluster(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Cluster",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cluster" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cluster" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cluster" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cluster" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (cosmobl::Cluster *)new cosmobl::Cluster(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Cluster",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cluster" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cluster" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cluster" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::Cluster *)new cosmobl::Cluster(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Cluster",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cluster" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cluster" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cluster" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Cluster" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cluster" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cluster" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cluster" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Cluster" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (cosmobl::Cluster *)new cosmobl::Cluster(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Cluster",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cluster" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cluster" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cluster" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Cluster" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cluster" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cluster" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Cluster" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Cluster *)new cosmobl::Cluster(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Cluster",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cluster" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cluster" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cluster" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Cluster" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cluster" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Cluster" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Cluster *)new cosmobl::Cluster(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Cluster *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Cluster",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Cluster" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cluster" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cluster" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Cluster" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cluster" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  result = (cosmobl::Cluster *)new cosmobl::Cluster(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cluster(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Cluster__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Cluster__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Cluster__SWIG_8(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Cluster__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Cluster__SWIG_7(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Cluster__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Cluster__SWIG_6(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Cluster__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Cluster__SWIG_5(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Cluster'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Cluster::Cluster()\n"
    "    cosmobl::Cluster::Cluster(double const,double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cluster::Cluster(double const,double const,double const,double const,double const)\n"
    "    cosmobl::Cluster::Cluster(double const,double const,double const,double const)\n"
    "    cosmobl::Cluster::Cluster(double const,double const,double const)\n"
    "    cosmobl::Cluster::Cluster(double const,double const,double const,cosmobl::Cosmology const &,double const,double const,double const)\n"
    "    cosmobl::Cluster::Cluster(double const,double const,double const,cosmobl::Cosmology const &,double const,double const)\n"
    "    cosmobl::Cluster::Cluster(double const,double const,double const,cosmobl::Cosmology const &,double const)\n"
    "    cosmobl::Cluster::Cluster(double const,double const,double const,cosmobl::Cosmology const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Cluster(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cluster *arg1 = (cosmobl::Cluster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Cluster",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cluster" "', argument " "1"" of type '" "cosmobl::Cluster *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cluster * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cluster_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cluster *arg1 = (cosmobl::Cluster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cluster_mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cluster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cluster_mass" "', argument " "1"" of type '" "cosmobl::Cluster const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cluster * >(argp1);
  result = (double)((cosmobl::Cluster const *)arg1)->mass();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cluster_richness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cluster *arg1 = (cosmobl::Cluster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Cluster_richness",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cluster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cluster_richness" "', argument " "1"" of type '" "cosmobl::Cluster const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cluster * >(argp1);
  result = (double)((cosmobl::Cluster const *)arg1)->richness();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cluster_set_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cluster *arg1 = (cosmobl::Cluster *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cluster_set_mass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cluster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cluster_set_mass" "', argument " "1"" of type '" "cosmobl::Cluster *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cluster * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cluster_set_mass" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_mass(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Cluster_set_richness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cluster *arg1 = (cosmobl::Cluster *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Cluster_set_richness",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Cluster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cluster_set_richness" "', argument " "1"" of type '" "cosmobl::Cluster *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cluster * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cluster_set_richness" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_richness(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Cluster_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Cluster, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_XX__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_XX_",SWIG_From_int(static_cast< int >(cosmobl::_XX_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_YY__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_YY_",SWIG_From_int(static_cast< int >(cosmobl::_YY_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_ZZ__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_ZZ_",SWIG_From_int(static_cast< int >(cosmobl::_ZZ_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_RA__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_RA_",SWIG_From_int(static_cast< int >(cosmobl::_RA_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_DEC__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_DEC_",SWIG_From_int(static_cast< int >(cosmobl::_DEC_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_REDSHIFT__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_REDSHIFT_",SWIG_From_int(static_cast< int >(cosmobl::_REDSHIFT_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_DC__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_DC_",SWIG_From_int(static_cast< int >(cosmobl::_DC_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_WEIGHT__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_WEIGHT_",SWIG_From_int(static_cast< int >(cosmobl::_WEIGHT_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_MASS__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_MASS_",SWIG_From_int(static_cast< int >(cosmobl::_MASS_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_RICHNESS__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_RICHNESS_",SWIG_From_int(static_cast< int >(cosmobl::_RICHNESS_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_MAGNITUDE__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_MAGNITUDE_",SWIG_From_int(static_cast< int >(cosmobl::_MAGNITUDE_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_VX__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_VX_",SWIG_From_int(static_cast< int >(cosmobl::_VX_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_VY__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_VY_",SWIG_From_int(static_cast< int >(cosmobl::_VY_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_VZ__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_VZ_",SWIG_From_int(static_cast< int >(cosmobl::_VZ_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_REGION__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_REGION_",SWIG_From_int(static_cast< int >(cosmobl::_REGION_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_GENERIC__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_GENERIC_",SWIG_From_int(static_cast< int >(cosmobl::_GENERIC_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_RADIUS__swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "_RADIUS_",SWIG_From_int(static_cast< int >(cosmobl::_RADIUS_)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Catalogue")) SWIG_fail;
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Catalogue",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Catalogue" "', argument " "4"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "4"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Catalogue" "', argument " "5"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "5"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Catalogue",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Catalogue" "', argument " "4"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "4"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  cosmobl::Cosmology arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Catalogue",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Catalogue" "', argument " "4"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "4"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Catalogue" "', argument " "5"" of type '" "cosmobl::Cosmology""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "5"" of type '" "cosmobl::Cosmology""'");
    } else {
      cosmobl::Cosmology * temp = reinterpret_cast< cosmobl::Cosmology * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Catalogue" "', argument " "6"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "6"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  cosmobl::Cosmology arg5 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Catalogue",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Catalogue" "', argument " "4"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "4"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Catalogue" "', argument " "5"" of type '" "cosmobl::Cosmology""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "5"" of type '" "cosmobl::Cosmology""'");
    } else {
      cosmobl::Cosmology * temp = reinterpret_cast< cosmobl::Cosmology * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< shared_ptr< cosmobl::Object > > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Catalogue",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< std::shared_ptr< cosmobl::Object > >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< std::shared_ptr< cosmobl::Object > >""'");
    } else {
      std::vector< std::shared_ptr< cosmobl::Object > > * temp = reinterpret_cast< std::vector< std::shared_ptr< cosmobl::Object > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::string > > arg1 ;
  std::string arg2 ;
  double arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Catalogue",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< std::string > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< std::string > const""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Catalogue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::string > > arg1 ;
  std::string arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Catalogue",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< std::string > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< std::string > const""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::string > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Catalogue",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< std::string > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< std::string > const""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Catalogue",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Catalogue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Catalogue" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,(cosmobl::Cosmology const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string arg3 ;
  double arg4 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Catalogue",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Catalogue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,(cosmobl::Cosmology const &)*arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string arg3 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Catalogue",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,(cosmobl::Cosmology const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Catalogue",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,(cosmobl::Cosmology const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue arg1 ;
  double arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Catalogue",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cosmobl__Catalogue,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "cosmobl::Catalogue const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "cosmobl::Catalogue const""'");
    } else {
      cosmobl::Catalogue * temp = reinterpret_cast< cosmobl::Catalogue * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Catalogue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Catalogue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Catalogue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Catalogue" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_object__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_object",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_object" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object >""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->add_object(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_objects__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  SwigValueWrapper< std::vector< shared_ptr< cosmobl::Object > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< std::shared_ptr< cosmobl::Object > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< std::shared_ptr< cosmobl::Object > >""'");
    } else {
      std::vector< std::shared_ptr< cosmobl::Object > > * temp = reinterpret_cast< std::vector< std::shared_ptr< cosmobl::Object > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->add_objects(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_remove_objects",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_remove_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  (arg1)->remove_objects();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  SwigValueWrapper< std::vector< shared_ptr< cosmobl::Object > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_remove_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_remove_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< std::shared_ptr< cosmobl::Object > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< std::shared_ptr< cosmobl::Object > >""'");
    } else {
      std::vector< std::shared_ptr< cosmobl::Object > > * temp = reinterpret_cast< std::vector< std::shared_ptr< cosmobl::Object > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->remove_objects(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_xx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_xx",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_xx" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_xx" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->xx(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_yy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_yy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_yy" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_yy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->yy(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_zz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_zz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_zz" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_zz" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->zz(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_vx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_vx",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_vx" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_vx" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->vx(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_vy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_vy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_vy" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_vy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->vy(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_vz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_vz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_vz" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_vz" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->vz(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_dc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_dc" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_dc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->dc(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_ra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_ra",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_ra" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_ra" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->ra(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_dec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_dec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_dec" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_dec" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->dec(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_redshift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_redshift",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_redshift" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_redshift" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->redshift(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_weight" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_weight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->weight(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_region",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_region" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_region" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (long)((cosmobl::Catalogue const *)arg1)->region(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_Nregion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_Nregion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_Nregion" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  result = (int)((cosmobl::Catalogue const *)arg1)->Nregion();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_get_region_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< long > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_get_region_list",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_get_region_list" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  result = ((cosmobl::Catalogue const *)arg1)->get_region_list();
  resultobj = SWIG_NewPointerObj((new std::vector< long >(static_cast< const std::vector< long >& >(result))), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_mass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_mass" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_mass" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->mass(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_magnitude(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_magnitude",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_magnitude" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_magnitude" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->magnitude(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_richness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_richness",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_richness" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_richness" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->richness(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_generic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_generic",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_generic" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_generic" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->generic(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_radius(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_radius",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_radius" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_radius" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Catalogue const *)arg1)->radius(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_var",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  result = ((cosmobl::Catalogue const *)arg1)->var(arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_object(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::shared_ptr< cosmobl::Object > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_object",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_object" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_object" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((cosmobl::Catalogue const *)arg1)->object(arg2);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Object >(static_cast< const std::shared_ptr< cosmobl::Object >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_coordinates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_coordinates",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_coordinates" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_coordinates" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((cosmobl::Catalogue const *)arg1)->coordinates(arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_set_var(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_set_var",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_set_var" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_set_var" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_set_var" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_set_var" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->set_var(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_nObjects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_nObjects",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_nObjects" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  result = (int)((cosmobl::Catalogue const *)arg1)->nObjects();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_resize" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_MinMax_var__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Catalogue_MinMax_var",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_MinMax_var" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_MinMax_var" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_MinMax_var" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_MinMax_var" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Catalogue_MinMax_var" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ((cosmobl::Catalogue const *)arg1)->MinMax_var(arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_MinMax_var__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_MinMax_var",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_MinMax_var" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_MinMax_var" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_MinMax_var" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_MinMax_var" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  ((cosmobl::Catalogue const *)arg1)->MinMax_var(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_MinMax_var__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  SwigValueWrapper< std::vector< enum cosmobl::Var > > arg2 ;
  std::vector< std::vector< double > > *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Catalogue_MinMax_var",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_MinMax_var" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_MinMax_var" "', argument " "2"" of type '" "std::vector< cosmobl::Var > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_MinMax_var" "', argument " "2"" of type '" "std::vector< cosmobl::Var > const""'");
    } else {
      std::vector< cosmobl::Var > * temp = reinterpret_cast< std::vector< cosmobl::Var > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_MinMax_var" "', argument " "3"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_MinMax_var" "', argument " "3"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::vector< double > > * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Catalogue_MinMax_var" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ((cosmobl::Catalogue const *)arg1)->MinMax_var(arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_MinMax_var__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  SwigValueWrapper< std::vector< enum cosmobl::Var > > arg2 ;
  std::vector< std::vector< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_MinMax_var",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_MinMax_var" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_MinMax_var" "', argument " "2"" of type '" "std::vector< cosmobl::Var > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_MinMax_var" "', argument " "2"" of type '" "std::vector< cosmobl::Var > const""'");
    } else {
      std::vector< cosmobl::Var > * temp = reinterpret_cast< std::vector< cosmobl::Var > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_MinMax_var" "', argument " "3"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_MinMax_var" "', argument " "3"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::vector< double > > * >(argp3);
  ((cosmobl::Catalogue const *)arg1)->MinMax_var(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_MinMax_var__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_MinMax_var",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_MinMax_var" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_MinMax_var" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  result = ((cosmobl::Catalogue const *)arg1)->MinMax_var(arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_MinMax_var(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Catalogue_MinMax_var__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Catalogue_MinMax_var__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Catalogue_MinMax_var__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Catalogue_MinMax_var__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Catalogue_MinMax_var__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_MinMax_var'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::MinMax_var(cosmobl::Var const,std::vector< double > &,bool const) const\n"
    "    cosmobl::Catalogue::MinMax_var(cosmobl::Var const,std::vector< double > &) const\n"
    "    cosmobl::Catalogue::MinMax_var(std::vector< cosmobl::Var > const,std::vector< std::vector< double > > &,bool const) const\n"
    "    cosmobl::Catalogue::MinMax_var(std::vector< cosmobl::Var > const,std::vector< std::vector< double > > &) const\n"
    "    cosmobl::Catalogue::MinMax_var(cosmobl::Var const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_stats_var__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_stats_var",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_stats_var" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_stats_var" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_stats_var" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_stats_var" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  ((cosmobl::Catalogue const *)arg1)->stats_var(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_stats_var__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  SwigValueWrapper< std::vector< enum cosmobl::Var > > arg2 ;
  std::vector< std::vector< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_stats_var",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_stats_var" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_stats_var" "', argument " "2"" of type '" "std::vector< cosmobl::Var > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_stats_var" "', argument " "2"" of type '" "std::vector< cosmobl::Var > const""'");
    } else {
      std::vector< cosmobl::Var > * temp = reinterpret_cast< std::vector< cosmobl::Var > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_stats_var" "', argument " "3"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_stats_var" "', argument " "3"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::vector< double > > * >(argp3);
  ((cosmobl::Catalogue const *)arg1)->stats_var(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_stats_var(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Catalogue_stats_var__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Catalogue_stats_var__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_stats_var'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::stats_var(cosmobl::Var const,std::vector< double > &) const\n"
    "    cosmobl::Catalogue::stats_var(std::vector< cosmobl::Var > const,std::vector< std::vector< double > > &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  bool arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_var_distr" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Catalogue_var_distr" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Catalogue_var_distr" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Catalogue_var_distr" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Catalogue_var_distr" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Catalogue_var_distr" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Catalogue_var_distr" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Catalogue_var_distr" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_var_distr" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Catalogue_var_distr" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Catalogue_var_distr" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Catalogue_var_distr" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Catalogue_var_distr" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Catalogue_var_distr" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Catalogue_var_distr" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  double arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_var_distr" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Catalogue_var_distr" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Catalogue_var_distr" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Catalogue_var_distr" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Catalogue_var_distr" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Catalogue_var_distr" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_var_distr" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Catalogue_var_distr" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Catalogue_var_distr" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Catalogue_var_distr" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Catalogue_var_distr" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_var_distr" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Catalogue_var_distr" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Catalogue_var_distr" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Catalogue_var_distr" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_var_distr" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Catalogue_var_distr" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Catalogue_var_distr" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_var_distr" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Catalogue_var_distr" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_var_distr" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Catalogue_var_distr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Catalogue_var_distr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_var_distr" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_var_distr" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_var_distr" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_var_distr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ((cosmobl::Catalogue const *)arg1)->var_distr(arg2,*arg3,*arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_var_distr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[15] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 14) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Catalogue_var_distr__SWIG_9(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Catalogue_var_distr__SWIG_8(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Catalogue_var_distr__SWIG_7(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Catalogue_var_distr__SWIG_6(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Catalogue_var_distr__SWIG_5(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Catalogue_var_distr__SWIG_4(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Catalogue_var_distr__SWIG_3(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Catalogue_var_distr__SWIG_2(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Catalogue_var_distr__SWIG_1(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Catalogue_var_distr__SWIG_0(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_var_distr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const,std::string const,double const,bool const,double const,double const,bool const,bool const,double const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const,std::string const,double const,bool const,double const,double const,bool const,bool const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const,std::string const,double const,bool const,double const,double const,bool const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const,std::string const,double const,bool const,double const,double const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const,std::string const,double const,bool const,double const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const,std::string const,double const,bool const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const,std::string const,double const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const,std::string const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const,bool const) const\n"
    "    cosmobl::Catalogue::var_distr(cosmobl::Var const,std::vector< double > &,std::vector< double > &,int const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_weightedN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_weightedN",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_weightedN" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  result = (double)((cosmobl::Catalogue const *)arg1)->weightedN();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_computeComovingCoordinates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_computeComovingCoordinates",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_computeComovingCoordinates" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_computeComovingCoordinates" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_computeComovingCoordinates" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  (arg1)->computeComovingCoordinates((cosmobl::Cosmology const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_computePolarCoordinates__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_computePolarCoordinates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_computePolarCoordinates" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  (arg1)->computePolarCoordinates();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_computePolarCoordinates__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Catalogue_computePolarCoordinates",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_computePolarCoordinates" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_computePolarCoordinates" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_computePolarCoordinates" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Catalogue_computePolarCoordinates" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Catalogue_computePolarCoordinates" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->computePolarCoordinates((cosmobl::Cosmology const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_computePolarCoordinates__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_computePolarCoordinates",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_computePolarCoordinates" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_computePolarCoordinates" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_computePolarCoordinates" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Catalogue_computePolarCoordinates" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->computePolarCoordinates((cosmobl::Cosmology const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_computePolarCoordinates__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_computePolarCoordinates",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_computePolarCoordinates" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_computePolarCoordinates" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_computePolarCoordinates" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  (arg1)->computePolarCoordinates((cosmobl::Cosmology const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_computePolarCoordinates(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Catalogue_computePolarCoordinates__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_computePolarCoordinates__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Catalogue_computePolarCoordinates__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Catalogue_computePolarCoordinates__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_computePolarCoordinates'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::computePolarCoordinates()\n"
    "    cosmobl::Catalogue::computePolarCoordinates(cosmobl::Cosmology const &,double const,double const)\n"
    "    cosmobl::Catalogue::computePolarCoordinates(cosmobl::Cosmology const &,double const)\n"
    "    cosmobl::Catalogue::computePolarCoordinates(cosmobl::Cosmology const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_normalizeComovingCoordinates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_normalizeComovingCoordinates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_normalizeComovingCoordinates" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  (arg1)->normalizeComovingCoordinates();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_restoreComovingCoordinates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_restoreComovingCoordinates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_restoreComovingCoordinates" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  (arg1)->restoreComovingCoordinates();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_Order__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  SwigValueWrapper< std::vector< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_Order",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_Order" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_Order" "', argument " "2"" of type '" "std::vector< int > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_Order" "', argument " "2"" of type '" "std::vector< int > const""'");
    } else {
      std::vector< int > * temp = reinterpret_cast< std::vector< int > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->Order(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_Order__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Catalogue_Order",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_Order" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  (arg1)->Order();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_Order(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Catalogue_Order__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_Order__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_Order'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::Order(std::vector< int > const)\n"
    "    cosmobl::Catalogue::Order()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_write_comoving_coordinates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_write_comoving_coordinates",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_write_comoving_coordinates" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_write_comoving_coordinates" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Catalogue const *)arg1)->write_comoving_coordinates(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_write_obs_coordinates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_write_obs_coordinates",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_write_obs_coordinates" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_write_obs_coordinates" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Catalogue const *)arg1)->write_obs_coordinates(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_write_coordinates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_write_coordinates",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_write_coordinates" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Catalogue_write_coordinates" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((cosmobl::Catalogue const *)arg1)->write_coordinates(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_distance",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_distance" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_distance" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_distance" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_distance" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object >""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)((cosmobl::Catalogue const *)arg1)->distance(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_angsep_xyz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  int arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_angsep_xyz",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_angsep_xyz" "', argument " "1"" of type '" "cosmobl::Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_angsep_xyz" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_angsep_xyz" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_angsep_xyz" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object >""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)((cosmobl::Catalogue const *)arg1)->angsep_xyz(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::Catalogue result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue___iadd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue___iadd__" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue___iadd__" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue___iadd__" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->operator +=(arg2);
  resultobj = SWIG_NewPointerObj((new cosmobl::Catalogue(static_cast< const cosmobl::Catalogue& >(result))), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_cut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Catalogue_cut",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_cut" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_cut" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Catalogue_cut" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Catalogue_cut" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Catalogue_cut" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->cut(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_cut__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Var arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Catalogue_cut",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_cut" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_cut" "', argument " "2"" of type '" "cosmobl::Var""'");
  } 
  arg2 = static_cast< cosmobl::Var >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Catalogue_cut" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Catalogue_cut" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (arg1)->cut(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_cut(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Catalogue_cut__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Catalogue_cut__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_cut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::cut(cosmobl::Var const,double const,double const,bool const)\n"
    "    cosmobl::Catalogue::cut(cosmobl::Var const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_smooth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< enum cosmobl::Var > > arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Catalogue_smooth",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_smooth" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_smooth" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_smooth" "', argument " "3"" of type '" "std::vector< cosmobl::Var > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_smooth" "', argument " "3"" of type '" "std::vector< cosmobl::Var > const""'");
    } else {
      std::vector< cosmobl::Var > * temp = reinterpret_cast< std::vector< cosmobl::Var > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Catalogue_smooth" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (arg1)->smooth(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_smooth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::vector< enum cosmobl::Var > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Catalogue_smooth",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_smooth" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_smooth" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Catalogue_smooth" "', argument " "3"" of type '" "std::vector< cosmobl::Var > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_smooth" "', argument " "3"" of type '" "std::vector< cosmobl::Var > const""'");
    } else {
      std::vector< cosmobl::Var > * temp = reinterpret_cast< std::vector< cosmobl::Var > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (arg1)->smooth(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_smooth__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_smooth",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_smooth" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Catalogue_smooth" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (arg1)->smooth(arg2);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_smooth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Catalogue_smooth__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Catalogue_smooth__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Catalogue_smooth__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_smooth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::smooth(double const,std::vector< cosmobl::Var > const,int const)\n"
    "    cosmobl::Catalogue::smooth(double const,std::vector< cosmobl::Var > const)\n"
    "    cosmobl::Catalogue::smooth(double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::GenericObject > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Catalogue",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::GenericObject >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::GenericObject >""'");
    } else {
      std::vector< cosmobl::GenericObject > * temp = reinterpret_cast< std::vector< cosmobl::GenericObject > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::RandomObject > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Catalogue",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::RandomObject >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::RandomObject >""'");
    } else {
      std::vector< cosmobl::RandomObject > * temp = reinterpret_cast< std::vector< cosmobl::RandomObject > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::Mock > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Catalogue",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::Mock >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::Mock >""'");
    } else {
      std::vector< cosmobl::Mock > * temp = reinterpret_cast< std::vector< cosmobl::Mock > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::Halo > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Catalogue",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::Halo >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::Halo >""'");
    } else {
      std::vector< cosmobl::Halo > * temp = reinterpret_cast< std::vector< cosmobl::Halo > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::Galaxy > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Catalogue",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::Galaxy >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::Galaxy >""'");
    } else {
      std::vector< cosmobl::Galaxy > * temp = reinterpret_cast< std::vector< cosmobl::Galaxy > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::Cluster > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Catalogue",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::Cluster >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Catalogue" "', argument " "1"" of type '" "std::vector< cosmobl::Cluster >""'");
    } else {
      std::vector< cosmobl::Cluster > * temp = reinterpret_cast< std::vector< cosmobl::Cluster > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::Catalogue *)new cosmobl::Catalogue(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Catalogue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Catalogue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Catalogue__SWIG_6(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Catalogue__SWIG_9(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Catalogue__SWIG_15(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Catalogue__SWIG_16(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Catalogue__SWIG_17(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Catalogue__SWIG_18(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Catalogue__SWIG_19(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Catalogue__SWIG_20(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Catalogue__SWIG_8(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Catalogue__SWIG_14(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Catalogue__SWIG_13(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Catalogue__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Catalogue__SWIG_12(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Catalogue__SWIG_11(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Catalogue__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_Catalogue__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Catalogue__SWIG_10(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_Catalogue__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Catalogue__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Catalogue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::Catalogue()\n"
    "    cosmobl::Catalogue::Catalogue(std::string,std::vector< double >,std::vector< double >,std::vector< double >,std::vector< double >)\n"
    "    cosmobl::Catalogue::Catalogue(std::string,std::vector< double >,std::vector< double >,std::vector< double >)\n"
    "    cosmobl::Catalogue::Catalogue(std::string,std::vector< double >,std::vector< double >,std::vector< double >,cosmobl::Cosmology,std::vector< double >)\n"
    "    cosmobl::Catalogue::Catalogue(std::string,std::vector< double >,std::vector< double >,std::vector< double >,cosmobl::Cosmology)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< std::shared_ptr< cosmobl::Object > >)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< std::string > const,std::string,double const)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< std::string > const,std::string)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< std::string > const)\n"
    "    cosmobl::Catalogue::Catalogue(std::string const,cosmobl::Cosmology const &,std::string,double const,double const)\n"
    "    cosmobl::Catalogue::Catalogue(std::string const,cosmobl::Cosmology const &,std::string,double const)\n"
    "    cosmobl::Catalogue::Catalogue(std::string const,cosmobl::Cosmology const &,std::string)\n"
    "    cosmobl::Catalogue::Catalogue(std::string const,cosmobl::Cosmology const &)\n"
    "    cosmobl::Catalogue::Catalogue(cosmobl::Catalogue const,double const)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< cosmobl::GenericObject >)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< cosmobl::RandomObject >)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< cosmobl::Mock >)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< cosmobl::Halo >)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< cosmobl::Galaxy >)\n"
    "    cosmobl::Catalogue::Catalogue(std::vector< cosmobl::Cluster >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_object__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::GenericObject arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_object",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_object" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::GenericObject""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::GenericObject""'");
    } else {
      cosmobl::GenericObject * temp = reinterpret_cast< cosmobl::GenericObject * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_object< cosmobl::GenericObject >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_object__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::RandomObject arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_object",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_object" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::RandomObject""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::RandomObject""'");
    } else {
      cosmobl::RandomObject * temp = reinterpret_cast< cosmobl::RandomObject * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_object< cosmobl::RandomObject >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_object__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Mock arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_object",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_object" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::Mock""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::Mock""'");
    } else {
      cosmobl::Mock * temp = reinterpret_cast< cosmobl::Mock * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_object< cosmobl::Mock >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_object__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Halo arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_object",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_object" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::Halo""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::Halo""'");
    } else {
      cosmobl::Halo * temp = reinterpret_cast< cosmobl::Halo * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_object< cosmobl::Halo >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_object__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Galaxy arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_object",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_object" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::Galaxy""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::Galaxy""'");
    } else {
      cosmobl::Galaxy * temp = reinterpret_cast< cosmobl::Galaxy * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_object< cosmobl::Galaxy >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_object__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  cosmobl::Cluster arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_object",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_object" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::Cluster""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_object" "', argument " "2"" of type '" "cosmobl::Cluster""'");
    } else {
      cosmobl::Cluster * temp = reinterpret_cast< cosmobl::Cluster * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_object< cosmobl::Cluster >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_object(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_object__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__RandomObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_object__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Mock, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_object__SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Halo, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_object__SWIG_5(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Galaxy, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_object__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cluster, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_object__SWIG_7(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__GenericObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_object__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_add_object'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::add_object(std::shared_ptr< cosmobl::Object >)\n"
    "    cosmobl::Catalogue::add_object< cosmobl::GenericObject >(cosmobl::GenericObject)\n"
    "    cosmobl::Catalogue::add_object< cosmobl::RandomObject >(cosmobl::RandomObject)\n"
    "    cosmobl::Catalogue::add_object< cosmobl::Mock >(cosmobl::Mock)\n"
    "    cosmobl::Catalogue::add_object< cosmobl::Halo >(cosmobl::Halo)\n"
    "    cosmobl::Catalogue::add_object< cosmobl::Galaxy >(cosmobl::Galaxy)\n"
    "    cosmobl::Catalogue::add_object< cosmobl::Cluster >(cosmobl::Cluster)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_objects__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::GenericObject > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::GenericObject >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::GenericObject >""'");
    } else {
      std::vector< cosmobl::GenericObject > * temp = reinterpret_cast< std::vector< cosmobl::GenericObject > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_objects< cosmobl::GenericObject >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_objects__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::RandomObject > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::RandomObject >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::RandomObject >""'");
    } else {
      std::vector< cosmobl::RandomObject > * temp = reinterpret_cast< std::vector< cosmobl::RandomObject > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_objects< cosmobl::RandomObject >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_objects__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::Mock > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Mock >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Mock >""'");
    } else {
      std::vector< cosmobl::Mock > * temp = reinterpret_cast< std::vector< cosmobl::Mock > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_objects< cosmobl::Mock >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_objects__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::Halo > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Halo >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Halo >""'");
    } else {
      std::vector< cosmobl::Halo > * temp = reinterpret_cast< std::vector< cosmobl::Halo > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_objects< cosmobl::Halo >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_objects__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::Galaxy > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Galaxy >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Galaxy >""'");
    } else {
      std::vector< cosmobl::Galaxy > * temp = reinterpret_cast< std::vector< cosmobl::Galaxy > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_objects< cosmobl::Galaxy >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_objects__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::Cluster > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_add_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_add_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Cluster >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_add_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Cluster >""'");
    } else {
      std::vector< cosmobl::Cluster > * temp = reinterpret_cast< std::vector< cosmobl::Cluster > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR add_objects< cosmobl::Cluster >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_add_objects(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_objects__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_objects__SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_objects__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_objects__SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_objects__SWIG_5(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_objects__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_add_objects__SWIG_7(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_add_objects'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::add_objects(std::vector< std::shared_ptr< cosmobl::Object > >)\n"
    "    cosmobl::Catalogue::add_objects< cosmobl::GenericObject >(std::vector< cosmobl::GenericObject >)\n"
    "    cosmobl::Catalogue::add_objects< cosmobl::RandomObject >(std::vector< cosmobl::RandomObject >)\n"
    "    cosmobl::Catalogue::add_objects< cosmobl::Mock >(std::vector< cosmobl::Mock >)\n"
    "    cosmobl::Catalogue::add_objects< cosmobl::Halo >(std::vector< cosmobl::Halo >)\n"
    "    cosmobl::Catalogue::add_objects< cosmobl::Galaxy >(std::vector< cosmobl::Galaxy >)\n"
    "    cosmobl::Catalogue::add_objects< cosmobl::Cluster >(std::vector< cosmobl::Cluster >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::GenericObject > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_remove_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_remove_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::GenericObject >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::GenericObject >""'");
    } else {
      std::vector< cosmobl::GenericObject > * temp = reinterpret_cast< std::vector< cosmobl::GenericObject > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR remove_objects< cosmobl::GenericObject >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::RandomObject > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_remove_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_remove_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::RandomObject >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::RandomObject >""'");
    } else {
      std::vector< cosmobl::RandomObject > * temp = reinterpret_cast< std::vector< cosmobl::RandomObject > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR remove_objects< cosmobl::RandomObject >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::Mock > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_remove_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_remove_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Mock >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Mock >""'");
    } else {
      std::vector< cosmobl::Mock > * temp = reinterpret_cast< std::vector< cosmobl::Mock > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR remove_objects< cosmobl::Mock >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::Halo > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_remove_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_remove_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Halo >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Halo >""'");
    } else {
      std::vector< cosmobl::Halo > * temp = reinterpret_cast< std::vector< cosmobl::Halo > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR remove_objects< cosmobl::Halo >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::Galaxy > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_remove_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_remove_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Galaxy >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Galaxy >""'");
    } else {
      std::vector< cosmobl::Galaxy > * temp = reinterpret_cast< std::vector< cosmobl::Galaxy > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR remove_objects< cosmobl::Galaxy >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue *arg1 = (cosmobl::Catalogue *) 0 ;
  std::vector< cosmobl::Cluster > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Catalogue_remove_objects",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Catalogue_remove_objects" "', argument " "1"" of type '" "cosmobl::Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Cluster >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Catalogue_remove_objects" "', argument " "2"" of type '" "std::vector< cosmobl::Cluster >""'");
    } else {
      std::vector< cosmobl::Cluster > * temp = reinterpret_cast< std::vector< cosmobl::Cluster > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->SWIGTEMPLATEDISAMBIGUATOR remove_objects< cosmobl::Cluster >(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Catalogue_remove_objects(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Catalogue_remove_objects__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_remove_objects__SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_remove_objects__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_remove_objects__SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_remove_objects__SWIG_5(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_remove_objects__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_remove_objects__SWIG_7(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Catalogue_remove_objects__SWIG_8(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Catalogue_remove_objects'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Catalogue::remove_objects()\n"
    "    cosmobl::Catalogue::remove_objects(std::vector< std::shared_ptr< cosmobl::Object > >)\n"
    "    cosmobl::Catalogue::remove_objects< cosmobl::GenericObject >(std::vector< cosmobl::GenericObject >)\n"
    "    cosmobl::Catalogue::remove_objects< cosmobl::RandomObject >(std::vector< cosmobl::RandomObject >)\n"
    "    cosmobl::Catalogue::remove_objects< cosmobl::Mock >(std::vector< cosmobl::Mock >)\n"
    "    cosmobl::Catalogue::remove_objects< cosmobl::Halo >(std::vector< cosmobl::Halo >)\n"
    "    cosmobl::Catalogue::remove_objects< cosmobl::Galaxy >(std::vector< cosmobl::Galaxy >)\n"
    "    cosmobl::Catalogue::remove_objects< cosmobl::Cluster >(std::vector< cosmobl::Cluster >)\n");
  return 0;
}


SWIGINTERN PyObject *Catalogue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Catalogue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ChainMesh_Catalogue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh_Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ChainMesh_Catalogue")) SWIG_fail;
  result = (cosmobl::ChainMesh_Catalogue *)new cosmobl::ChainMesh_Catalogue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ChainMesh_Catalogue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh_Catalogue *arg1 = (cosmobl::ChainMesh_Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainMesh_Catalogue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainMesh_Catalogue" "', argument " "1"" of type '" "cosmobl::ChainMesh_Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh_Catalogue * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_Catalogue_set_par(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh_Catalogue *arg1 = (cosmobl::ChainMesh_Catalogue *) 0 ;
  double arg2 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ChainMesh_Catalogue_set_par",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_Catalogue_set_par" "', argument " "1"" of type '" "cosmobl::ChainMesh_Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh_Catalogue * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChainMesh_Catalogue_set_par" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ChainMesh_Catalogue_set_par" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_Catalogue_set_par" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ChainMesh_Catalogue_set_par" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_par(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh_Catalogue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::ChainMesh_Catalogue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ChainMesh_Catalogue",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChainMesh_Catalogue" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainMesh_Catalogue" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainMesh_Catalogue" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainMesh_Catalogue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (cosmobl::ChainMesh_Catalogue *)new cosmobl::ChainMesh_Catalogue(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChainMesh_Catalogue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ChainMesh_Catalogue__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ChainMesh_Catalogue__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ChainMesh_Catalogue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh_Catalogue::ChainMesh_Catalogue()\n"
    "    cosmobl::ChainMesh_Catalogue::ChainMesh_Catalogue(double const,std::shared_ptr< cosmobl::Catalogue >,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ChainMesh_Catalogue_get_order(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh_Catalogue *arg1 = (cosmobl::ChainMesh_Catalogue *) 0 ;
  std::vector< int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ChainMesh_Catalogue_get_order",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_Catalogue_get_order" "', argument " "1"" of type '" "cosmobl::ChainMesh_Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh_Catalogue * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_Catalogue_get_order" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_Catalogue_get_order" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
  ((cosmobl::ChainMesh_Catalogue const *)arg1)->get_order(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_Catalogue_object_list__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh_Catalogue *arg1 = (cosmobl::ChainMesh_Catalogue *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigValueWrapper< std::vector< shared_ptr< cosmobl::Object > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ChainMesh_Catalogue_object_list",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_Catalogue_object_list" "', argument " "1"" of type '" "cosmobl::ChainMesh_Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh_Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_Catalogue_object_list" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_Catalogue_object_list" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object >""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ChainMesh_Catalogue_object_list" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (arg1)->object_list(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::vector< std::shared_ptr< cosmobl::Object > >(static_cast< const std::vector< std::shared_ptr< cosmobl::Object > >& >(result))), SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_Catalogue_object_list__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh_Catalogue *arg1 = (cosmobl::ChainMesh_Catalogue *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::vector< shared_ptr< cosmobl::Object > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ChainMesh_Catalogue_object_list",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_Catalogue_object_list" "', argument " "1"" of type '" "cosmobl::ChainMesh_Catalogue *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh_Catalogue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainMesh_Catalogue_object_list" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainMesh_Catalogue_object_list" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object >""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->object_list(arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< std::shared_ptr< cosmobl::Object > >(static_cast< const std::vector< std::shared_ptr< cosmobl::Object > >& >(result))), SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChainMesh_Catalogue_object_list(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ChainMesh_Catalogue_object_list__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ChainMesh_Catalogue_object_list__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ChainMesh_Catalogue_object_list'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ChainMesh_Catalogue::object_list(std::shared_ptr< cosmobl::Object >,int const)\n"
    "    cosmobl::ChainMesh_Catalogue::object_list(std::shared_ptr< cosmobl::Object >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ChainMesh_Catalogue_catalogue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ChainMesh_Catalogue *arg1 = (cosmobl::ChainMesh_Catalogue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ChainMesh_Catalogue_catalogue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainMesh_Catalogue_catalogue" "', argument " "1"" of type '" "cosmobl::ChainMesh_Catalogue const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ChainMesh_Catalogue * >(argp1);
  result = ((cosmobl::ChainMesh_Catalogue const *)arg1)->catalogue();
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ChainMesh_Catalogue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_GenericObjVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_iterator" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (swig::SwigPyIterator *)vector_Sl_cosmobl_GenericObject_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___nonzero__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (bool)vector_Sl_cosmobl_GenericObject_Sg____nonzero__((vector< cosmobl::GenericObject > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___bool__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (bool)vector_Sl_cosmobl_GenericObject_Sg____bool__((vector< cosmobl::GenericObject > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___len__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = vector_Sl_cosmobl_GenericObject_Sg____len__((vector< cosmobl::GenericObject > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_pop" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  try {
    result = vector_Sl_cosmobl_GenericObject_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::GenericObject >::value_type(static_cast< const vector< cosmobl::GenericObject >::value_type& >(result))), SWIGTYPE_p_cosmobl__GenericObject, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::difference_type arg2 ;
  vector< cosmobl::GenericObject >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___getslice__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec___getslice__" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenericObjVec___getslice__" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val3);
  try {
    result = (std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *)vector_Sl_cosmobl_GenericObject_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::difference_type arg2 ;
  vector< cosmobl::GenericObject >::difference_type arg3 ;
  std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:GenericObjVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenericObjVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val3);
  {
    std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *ptr = (std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenericObjVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    vector_Sl_cosmobl_GenericObject_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::difference_type arg2 ;
  vector< cosmobl::GenericObject >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenericObjVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_GenericObject_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___setslice__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GenericObjVec___setslice____SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_GenericObjVec___setslice____SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenericObjVec___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::GenericObject >::__setslice__(vector< cosmobl::GenericObject >::difference_type,vector< cosmobl::GenericObject >::difference_type,std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &)\n"
    "    vector< cosmobl::GenericObject >::__setslice__(vector< cosmobl::GenericObject >::difference_type,vector< cosmobl::GenericObject >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::difference_type arg2 ;
  vector< cosmobl::GenericObject >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___delslice__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec___delslice__" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenericObjVec___delslice__" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_GenericObject_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec___delitem__" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val2);
  try {
    vector_Sl_cosmobl_GenericObject_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *)vector_Sl_cosmobl_GenericObject_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *ptr = (std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenericObjVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    vector_Sl_cosmobl_GenericObject_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_GenericObject_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_GenericObject_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___delitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_GenericObjVec___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GenericObjVec___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenericObjVec___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::GenericObject >::__delitem__(vector< cosmobl::GenericObject >::difference_type)\n"
    "    vector< cosmobl::GenericObject >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::GenericObject >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec___getitem__" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val2);
  try {
    result = (vector< cosmobl::GenericObject >::value_type *) &vector_Sl_cosmobl_GenericObject_Sg____getitem____SWIG_1((vector< cosmobl::GenericObject > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___getitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_GenericObjVec___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GenericObjVec___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenericObjVec___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::GenericObject >::__getitem__(PySliceObject *)\n"
    "    vector< cosmobl::GenericObject >::__getitem__(vector< cosmobl::GenericObject >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::difference_type arg2 ;
  vector< cosmobl::GenericObject >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec___setitem__" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenericObjVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::GenericObject >::value_type * >(argp3);
  try {
    vector_Sl_cosmobl_GenericObject_Sg____setitem____SWIG_2(arg1,arg2,(cosmobl::GenericObject const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec___setitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_GenericObjVec___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GenericObjVec___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__GenericObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GenericObjVec___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenericObjVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::GenericObject >::__setitem__(PySliceObject *,std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > const &)\n"
    "    vector< cosmobl::GenericObject >::__setitem__(PySliceObject *)\n"
    "    vector< cosmobl::GenericObject >::__setitem__(vector< cosmobl::GenericObject >::difference_type,vector< cosmobl::GenericObject >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_append" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericObjVec_append" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec_append" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::GenericObject >::value_type * >(argp2);
  vector_Sl_cosmobl_GenericObject_Sg__append(arg1,(cosmobl::GenericObject const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObjVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GenericObjVec")) SWIG_fail;
  result = (vector< cosmobl::GenericObject > *)new vector< cosmobl::GenericObject >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObjVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::GenericObject > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GenericObjVec",&obj0)) SWIG_fail;
  {
    std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *ptr = (std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenericObjVec" "', argument " "1"" of type '" "std::vector< cosmobl::GenericObject > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericObjVec" "', argument " "1"" of type '" "std::vector< cosmobl::GenericObject > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (vector< cosmobl::GenericObject > *)new vector< cosmobl::GenericObject >((std::vector< cosmobl::GenericObject > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_empty" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (bool)((vector< cosmobl::GenericObject > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_size" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = ((vector< cosmobl::GenericObject > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_clear" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  std::vector< cosmobl::GenericObject > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_swap" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericObjVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::GenericObject > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::GenericObject > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< cosmobl::GenericObject > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< cosmobl::GenericObject > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_get_allocator" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = ((vector< cosmobl::GenericObject > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::GenericObject >::allocator_type(static_cast< const vector< cosmobl::GenericObject >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_cosmobl__GenericObject_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_begin" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::GenericObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_end" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::GenericObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_rbegin" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::GenericObject >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_rend" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::GenericObject >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObjVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GenericObjVec",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObjVec" "', argument " "1"" of type '" "vector< cosmobl::GenericObject >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::GenericObject >::size_type >(val1);
  result = (vector< cosmobl::GenericObject > *)new vector< cosmobl::GenericObject >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_pop_back" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_resize" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec_resize" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::GenericObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_erase" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_erase" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_erase" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_GenericObject_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::GenericObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::iterator arg2 ;
  vector< cosmobl::GenericObject >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::GenericObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_erase" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_erase" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_erase" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_erase" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_erase" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_GenericObject_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::GenericObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_erase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_GenericObjVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_GenericObjVec_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenericObjVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::GenericObject >::erase(vector< cosmobl::GenericObject >::iterator)\n"
    "    vector< cosmobl::GenericObject >::erase(vector< cosmobl::GenericObject >::iterator,vector< cosmobl::GenericObject >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_GenericObjVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject >::size_type arg1 ;
  vector< cosmobl::GenericObject >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::GenericObject > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_GenericObjVec",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GenericObjVec" "', argument " "1"" of type '" "vector< cosmobl::GenericObject >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::GenericObject >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GenericObjVec" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericObjVec" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::GenericObject >::value_type * >(argp2);
  result = (vector< cosmobl::GenericObject > *)new vector< cosmobl::GenericObject >(arg1,(vector< cosmobl::GenericObject >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericObjVec(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_GenericObjVec__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GenericObjVec__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GenericObjVec__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__GenericObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GenericObjVec__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GenericObjVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::GenericObject >::vector()\n"
    "    vector< cosmobl::GenericObject >::vector(std::vector< cosmobl::GenericObject > const &)\n"
    "    vector< cosmobl::GenericObject >::vector(vector< cosmobl::GenericObject >::size_type)\n"
    "    vector< cosmobl::GenericObject >::vector(vector< cosmobl::GenericObject >::size_type,vector< cosmobl::GenericObject >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_push_back" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericObjVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::GenericObject >::value_type * >(argp2);
  (arg1)->push_back((vector< cosmobl::GenericObject >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_front" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (vector< cosmobl::GenericObject >::value_type *) &((vector< cosmobl::GenericObject > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_back" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = (vector< cosmobl::GenericObject >::value_type *) &((vector< cosmobl::GenericObject > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__GenericObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::size_type arg2 ;
  vector< cosmobl::GenericObject >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_assign" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec_assign" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenericObjVec_assign" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec_assign" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::GenericObject >::value_type * >(argp3);
  (arg1)->assign(arg2,(vector< cosmobl::GenericObject >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::size_type arg2 ;
  vector< cosmobl::GenericObject >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_resize" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec_resize" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenericObjVec_resize" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec_resize" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::GenericObject >::value_type * >(argp3);
  (arg1)->resize(arg2,(vector< cosmobl::GenericObject >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_resize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GenericObjVec_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__GenericObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GenericObjVec_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenericObjVec_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::GenericObject >::resize(vector< cosmobl::GenericObject >::size_type)\n"
    "    vector< cosmobl::GenericObject >::resize(vector< cosmobl::GenericObject >::size_type,vector< cosmobl::GenericObject >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::iterator arg2 ;
  vector< cosmobl::GenericObject >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::GenericObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GenericObjVec_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_insert" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_insert" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_insert" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenericObjVec_insert" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec_insert" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::GenericObject >::value_type * >(argp3);
  result = vector_Sl_cosmobl_GenericObject_Sg__insert__SWIG_0(arg1,arg2,(cosmobl::GenericObject const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::GenericObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::iterator arg2 ;
  vector< cosmobl::GenericObject >::size_type arg3 ;
  vector< cosmobl::GenericObject >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:GenericObjVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_insert" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_insert" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GenericObjVec_insert" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenericObjVec_insert" "', argument " "3"" of type '" "vector< cosmobl::GenericObject >::size_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::GenericObject >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__GenericObject,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenericObjVec_insert" "', argument " "4"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericObjVec_insert" "', argument " "4"" of type '" "vector< cosmobl::GenericObject >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< vector< cosmobl::GenericObject >::value_type * >(argp4);
  vector_Sl_cosmobl_GenericObject_Sg__insert__SWIG_1(arg1,arg2,arg3,(cosmobl::GenericObject const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_insert(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__GenericObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GenericObjVec_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::GenericObject >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__GenericObject, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_GenericObjVec_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenericObjVec_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::GenericObject >::insert(vector< cosmobl::GenericObject >::iterator,vector< cosmobl::GenericObject >::value_type const &)\n"
    "    vector< cosmobl::GenericObject >::insert(vector< cosmobl::GenericObject >::iterator,vector< cosmobl::GenericObject >::size_type,vector< cosmobl::GenericObject >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  vector< cosmobl::GenericObject >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GenericObjVec_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_reserve" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericObjVec_reserve" "', argument " "2"" of type '" "vector< cosmobl::GenericObject >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::GenericObject >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericObjVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::GenericObject >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GenericObjVec_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericObjVec_capacity" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  result = ((vector< cosmobl::GenericObject > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GenericObjVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::GenericObject > *arg1 = (vector< cosmobl::GenericObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GenericObjVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenericObjVec" "', argument " "1"" of type '" "vector< cosmobl::GenericObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::GenericObject > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GenericObjVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_RandomObjVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_iterator" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (swig::SwigPyIterator *)vector_Sl_cosmobl_RandomObject_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___nonzero__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (bool)vector_Sl_cosmobl_RandomObject_Sg____nonzero__((vector< cosmobl::RandomObject > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___bool__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (bool)vector_Sl_cosmobl_RandomObject_Sg____bool__((vector< cosmobl::RandomObject > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___len__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = vector_Sl_cosmobl_RandomObject_Sg____len__((vector< cosmobl::RandomObject > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_pop" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  try {
    result = vector_Sl_cosmobl_RandomObject_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::RandomObject >::value_type(static_cast< const vector< cosmobl::RandomObject >::value_type& >(result))), SWIGTYPE_p_cosmobl__RandomObject, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::difference_type arg2 ;
  vector< cosmobl::RandomObject >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___getslice__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec___getslice__" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RandomObjVec___getslice__" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val3);
  try {
    result = (std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *)vector_Sl_cosmobl_RandomObject_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::difference_type arg2 ;
  vector< cosmobl::RandomObject >::difference_type arg3 ;
  std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:RandomObjVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RandomObjVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val3);
  {
    std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *ptr = (std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RandomObjVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    vector_Sl_cosmobl_RandomObject_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::difference_type arg2 ;
  vector< cosmobl::RandomObject >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RandomObjVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_RandomObject_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___setslice__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RandomObjVec___setslice____SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RandomObjVec___setslice____SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RandomObjVec___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::RandomObject >::__setslice__(vector< cosmobl::RandomObject >::difference_type,vector< cosmobl::RandomObject >::difference_type,std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &)\n"
    "    vector< cosmobl::RandomObject >::__setslice__(vector< cosmobl::RandomObject >::difference_type,vector< cosmobl::RandomObject >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::difference_type arg2 ;
  vector< cosmobl::RandomObject >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___delslice__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec___delslice__" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RandomObjVec___delslice__" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_RandomObject_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec___delitem__" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val2);
  try {
    vector_Sl_cosmobl_RandomObject_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *)vector_Sl_cosmobl_RandomObject_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *ptr = (std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RandomObjVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    vector_Sl_cosmobl_RandomObject_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_RandomObject_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_RandomObject_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___delitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RandomObjVec___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RandomObjVec___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RandomObjVec___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::RandomObject >::__delitem__(vector< cosmobl::RandomObject >::difference_type)\n"
    "    vector< cosmobl::RandomObject >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::RandomObject >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec___getitem__" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val2);
  try {
    result = (vector< cosmobl::RandomObject >::value_type *) &vector_Sl_cosmobl_RandomObject_Sg____getitem____SWIG_1((vector< cosmobl::RandomObject > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___getitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RandomObjVec___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RandomObjVec___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RandomObjVec___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::RandomObject >::__getitem__(PySliceObject *)\n"
    "    vector< cosmobl::RandomObject >::__getitem__(vector< cosmobl::RandomObject >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::difference_type arg2 ;
  vector< cosmobl::RandomObject >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec___setitem__" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RandomObjVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::RandomObject >::value_type * >(argp3);
  try {
    vector_Sl_cosmobl_RandomObject_Sg____setitem____SWIG_2(arg1,arg2,(cosmobl::RandomObject const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec___setitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RandomObjVec___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RandomObjVec___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__RandomObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RandomObjVec___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RandomObjVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::RandomObject >::__setitem__(PySliceObject *,std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > const &)\n"
    "    vector< cosmobl::RandomObject >::__setitem__(PySliceObject *)\n"
    "    vector< cosmobl::RandomObject >::__setitem__(vector< cosmobl::RandomObject >::difference_type,vector< cosmobl::RandomObject >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_append" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RandomObjVec_append" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec_append" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::RandomObject >::value_type * >(argp2);
  vector_Sl_cosmobl_RandomObject_Sg__append(arg1,(cosmobl::RandomObject const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObjVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RandomObjVec")) SWIG_fail;
  result = (vector< cosmobl::RandomObject > *)new vector< cosmobl::RandomObject >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObjVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::RandomObject > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RandomObjVec",&obj0)) SWIG_fail;
  {
    std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *ptr = (std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RandomObjVec" "', argument " "1"" of type '" "std::vector< cosmobl::RandomObject > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RandomObjVec" "', argument " "1"" of type '" "std::vector< cosmobl::RandomObject > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (vector< cosmobl::RandomObject > *)new vector< cosmobl::RandomObject >((std::vector< cosmobl::RandomObject > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_empty" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (bool)((vector< cosmobl::RandomObject > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_size" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = ((vector< cosmobl::RandomObject > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_clear" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  std::vector< cosmobl::RandomObject > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_swap" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RandomObjVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::RandomObject > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::RandomObject > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< cosmobl::RandomObject > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< cosmobl::RandomObject > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_get_allocator" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = ((vector< cosmobl::RandomObject > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::RandomObject >::allocator_type(static_cast< const vector< cosmobl::RandomObject >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_cosmobl__RandomObject_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_begin" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::RandomObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_end" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::RandomObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_rbegin" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::RandomObject >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_rend" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::RandomObject >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObjVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RandomObjVec",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObjVec" "', argument " "1"" of type '" "vector< cosmobl::RandomObject >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::RandomObject >::size_type >(val1);
  result = (vector< cosmobl::RandomObject > *)new vector< cosmobl::RandomObject >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_pop_back" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_resize" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec_resize" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::RandomObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_erase" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_erase" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_erase" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_RandomObject_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::RandomObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::iterator arg2 ;
  vector< cosmobl::RandomObject >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::RandomObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_erase" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_erase" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_erase" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_erase" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_erase" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_RandomObject_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::RandomObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_erase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_RandomObjVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_RandomObjVec_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RandomObjVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::RandomObject >::erase(vector< cosmobl::RandomObject >::iterator)\n"
    "    vector< cosmobl::RandomObject >::erase(vector< cosmobl::RandomObject >::iterator,vector< cosmobl::RandomObject >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_RandomObjVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject >::size_type arg1 ;
  vector< cosmobl::RandomObject >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::RandomObject > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_RandomObjVec",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RandomObjVec" "', argument " "1"" of type '" "vector< cosmobl::RandomObject >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::RandomObject >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RandomObjVec" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RandomObjVec" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::RandomObject >::value_type * >(argp2);
  result = (vector< cosmobl::RandomObject > *)new vector< cosmobl::RandomObject >(arg1,(vector< cosmobl::RandomObject >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RandomObjVec(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_RandomObjVec__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RandomObjVec__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RandomObjVec__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__RandomObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RandomObjVec__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RandomObjVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::RandomObject >::vector()\n"
    "    vector< cosmobl::RandomObject >::vector(std::vector< cosmobl::RandomObject > const &)\n"
    "    vector< cosmobl::RandomObject >::vector(vector< cosmobl::RandomObject >::size_type)\n"
    "    vector< cosmobl::RandomObject >::vector(vector< cosmobl::RandomObject >::size_type,vector< cosmobl::RandomObject >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_push_back" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RandomObjVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::RandomObject >::value_type * >(argp2);
  (arg1)->push_back((vector< cosmobl::RandomObject >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_front" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (vector< cosmobl::RandomObject >::value_type *) &((vector< cosmobl::RandomObject > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_back" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = (vector< cosmobl::RandomObject >::value_type *) &((vector< cosmobl::RandomObject > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__RandomObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::size_type arg2 ;
  vector< cosmobl::RandomObject >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_assign" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec_assign" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RandomObjVec_assign" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec_assign" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::RandomObject >::value_type * >(argp3);
  (arg1)->assign(arg2,(vector< cosmobl::RandomObject >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::size_type arg2 ;
  vector< cosmobl::RandomObject >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_resize" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec_resize" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RandomObjVec_resize" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec_resize" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::RandomObject >::value_type * >(argp3);
  (arg1)->resize(arg2,(vector< cosmobl::RandomObject >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_resize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RandomObjVec_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__RandomObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RandomObjVec_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RandomObjVec_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::RandomObject >::resize(vector< cosmobl::RandomObject >::size_type)\n"
    "    vector< cosmobl::RandomObject >::resize(vector< cosmobl::RandomObject >::size_type,vector< cosmobl::RandomObject >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::iterator arg2 ;
  vector< cosmobl::RandomObject >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::RandomObject >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RandomObjVec_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_insert" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_insert" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_insert" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RandomObjVec_insert" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec_insert" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::RandomObject >::value_type * >(argp3);
  result = vector_Sl_cosmobl_RandomObject_Sg__insert__SWIG_0(arg1,arg2,(cosmobl::RandomObject const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::RandomObject >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::iterator arg2 ;
  vector< cosmobl::RandomObject >::size_type arg3 ;
  vector< cosmobl::RandomObject >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:RandomObjVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_insert" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_insert" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RandomObjVec_insert" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RandomObjVec_insert" "', argument " "3"" of type '" "vector< cosmobl::RandomObject >::size_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::RandomObject >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__RandomObject,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RandomObjVec_insert" "', argument " "4"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RandomObjVec_insert" "', argument " "4"" of type '" "vector< cosmobl::RandomObject >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< vector< cosmobl::RandomObject >::value_type * >(argp4);
  vector_Sl_cosmobl_RandomObject_Sg__insert__SWIG_1(arg1,arg2,arg3,(cosmobl::RandomObject const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_insert(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__RandomObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RandomObjVec_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::RandomObject >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__RandomObject, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RandomObjVec_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RandomObjVec_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::RandomObject >::insert(vector< cosmobl::RandomObject >::iterator,vector< cosmobl::RandomObject >::value_type const &)\n"
    "    vector< cosmobl::RandomObject >::insert(vector< cosmobl::RandomObject >::iterator,vector< cosmobl::RandomObject >::size_type,vector< cosmobl::RandomObject >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  vector< cosmobl::RandomObject >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RandomObjVec_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_reserve" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RandomObjVec_reserve" "', argument " "2"" of type '" "vector< cosmobl::RandomObject >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::RandomObject >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RandomObjVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::RandomObject >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RandomObjVec_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RandomObjVec_capacity" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  result = ((vector< cosmobl::RandomObject > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RandomObjVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::RandomObject > *arg1 = (vector< cosmobl::RandomObject > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RandomObjVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RandomObjVec" "', argument " "1"" of type '" "vector< cosmobl::RandomObject > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::RandomObject > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RandomObjVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_MockVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_iterator" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (swig::SwigPyIterator *)vector_Sl_cosmobl_Mock_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___nonzero__" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (bool)vector_Sl_cosmobl_Mock_Sg____nonzero__((vector< cosmobl::Mock > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___bool__" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (bool)vector_Sl_cosmobl_Mock_Sg____bool__((vector< cosmobl::Mock > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___len__" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = vector_Sl_cosmobl_Mock_Sg____len__((vector< cosmobl::Mock > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_pop" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  try {
    result = vector_Sl_cosmobl_Mock_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::Mock >::value_type(static_cast< const vector< cosmobl::Mock >::value_type& >(result))), SWIGTYPE_p_cosmobl__Mock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::difference_type arg2 ;
  vector< cosmobl::Mock >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___getslice__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec___getslice__" "', argument " "2"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MockVec___getslice__" "', argument " "3"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Mock >::difference_type >(val3);
  try {
    result = (std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *)vector_Sl_cosmobl_Mock_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::difference_type arg2 ;
  vector< cosmobl::Mock >::difference_type arg3 ;
  std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MockVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MockVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Mock >::difference_type >(val3);
  {
    std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > > *ptr = (std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MockVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    vector_Sl_cosmobl_Mock_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::difference_type arg2 ;
  vector< cosmobl::Mock >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MockVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Mock >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_Mock_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___setslice__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MockVec___setslice____SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MockVec___setslice____SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MockVec___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Mock >::__setslice__(vector< cosmobl::Mock >::difference_type,vector< cosmobl::Mock >::difference_type,std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &)\n"
    "    vector< cosmobl::Mock >::__setslice__(vector< cosmobl::Mock >::difference_type,vector< cosmobl::Mock >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MockVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::difference_type arg2 ;
  vector< cosmobl::Mock >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___delslice__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec___delslice__" "', argument " "2"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MockVec___delslice__" "', argument " "3"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Mock >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_Mock_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec___delitem__" "', argument " "2"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::difference_type >(val2);
  try {
    vector_Sl_cosmobl_Mock_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *)vector_Sl_cosmobl_Mock_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > > *ptr = (std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MockVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    vector_Sl_cosmobl_Mock_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_Mock_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_Mock_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___delitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_MockVec___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MockVec___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MockVec___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Mock >::__delitem__(vector< cosmobl::Mock >::difference_type)\n"
    "    vector< cosmobl::Mock >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MockVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Mock >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec___getitem__" "', argument " "2"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::difference_type >(val2);
  try {
    result = (vector< cosmobl::Mock >::value_type *) &vector_Sl_cosmobl_Mock_Sg____getitem____SWIG_1((vector< cosmobl::Mock > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___getitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_MockVec___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MockVec___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MockVec___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Mock >::__getitem__(PySliceObject *)\n"
    "    vector< cosmobl::Mock >::__getitem__(vector< cosmobl::Mock >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MockVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::difference_type arg2 ;
  vector< cosmobl::Mock >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec___setitem__" "', argument " "2"" of type '" "vector< cosmobl::Mock >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MockVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Mock >::value_type * >(argp3);
  try {
    vector_Sl_cosmobl_Mock_Sg____setitem____SWIG_2(arg1,arg2,(cosmobl::Mock const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec___setitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_MockVec___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MockVec___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Mock, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MockVec___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MockVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Mock >::__setitem__(PySliceObject *,std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > const &)\n"
    "    vector< cosmobl::Mock >::__setitem__(PySliceObject *)\n"
    "    vector< cosmobl::Mock >::__setitem__(vector< cosmobl::Mock >::difference_type,vector< cosmobl::Mock >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MockVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_append" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MockVec_append" "', argument " "2"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec_append" "', argument " "2"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Mock >::value_type * >(argp2);
  vector_Sl_cosmobl_Mock_Sg__append(arg1,(cosmobl::Mock const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MockVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MockVec")) SWIG_fail;
  result = (vector< cosmobl::Mock > *)new vector< cosmobl::Mock >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MockVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::Mock > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MockVec",&obj0)) SWIG_fail;
  {
    std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > > *ptr = (std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MockVec" "', argument " "1"" of type '" "std::vector< cosmobl::Mock > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MockVec" "', argument " "1"" of type '" "std::vector< cosmobl::Mock > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (vector< cosmobl::Mock > *)new vector< cosmobl::Mock >((std::vector< cosmobl::Mock > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_empty" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (bool)((vector< cosmobl::Mock > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_size" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = ((vector< cosmobl::Mock > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_clear" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  std::vector< cosmobl::Mock > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_swap" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MockVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::Mock > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::Mock > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< cosmobl::Mock > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< cosmobl::Mock > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_get_allocator" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = ((vector< cosmobl::Mock > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::Mock >::allocator_type(static_cast< const vector< cosmobl::Mock >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_cosmobl__Mock_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_begin" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Mock >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_end" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Mock >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_rbegin" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Mock >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_rend" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Mock >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MockVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MockVec",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MockVec" "', argument " "1"" of type '" "vector< cosmobl::Mock >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::Mock >::size_type >(val1);
  result = (vector< cosmobl::Mock > *)new vector< cosmobl::Mock >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_pop_back" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_resize" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec_resize" "', argument " "2"" of type '" "vector< cosmobl::Mock >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Mock >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_erase" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Mock >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Mock >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_Mock_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Mock >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::iterator arg2 ;
  vector< cosmobl::Mock >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::Mock >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_erase" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Mock >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Mock >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_erase" "', argument " "3"" of type '" "vector< cosmobl::Mock >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_erase" "', argument " "3"" of type '" "vector< cosmobl::Mock >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_Mock_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Mock >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_erase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MockVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MockVec_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MockVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Mock >::erase(vector< cosmobl::Mock >::iterator)\n"
    "    vector< cosmobl::Mock >::erase(vector< cosmobl::Mock >::iterator,vector< cosmobl::Mock >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_MockVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock >::size_type arg1 ;
  vector< cosmobl::Mock >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Mock > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_MockVec",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MockVec" "', argument " "1"" of type '" "vector< cosmobl::Mock >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::Mock >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MockVec" "', argument " "2"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MockVec" "', argument " "2"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Mock >::value_type * >(argp2);
  result = (vector< cosmobl::Mock > *)new vector< cosmobl::Mock >(arg1,(vector< cosmobl::Mock >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MockVec(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MockVec__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MockVec__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<cosmobl::Mock,std::allocator< cosmobl::Mock > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MockVec__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Mock, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MockVec__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MockVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Mock >::vector()\n"
    "    vector< cosmobl::Mock >::vector(std::vector< cosmobl::Mock > const &)\n"
    "    vector< cosmobl::Mock >::vector(vector< cosmobl::Mock >::size_type)\n"
    "    vector< cosmobl::Mock >::vector(vector< cosmobl::Mock >::size_type,vector< cosmobl::Mock >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MockVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_push_back" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MockVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Mock >::value_type * >(argp2);
  (arg1)->push_back((vector< cosmobl::Mock >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_front" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (vector< cosmobl::Mock >::value_type *) &((vector< cosmobl::Mock > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_back" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = (vector< cosmobl::Mock >::value_type *) &((vector< cosmobl::Mock > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Mock, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::size_type arg2 ;
  vector< cosmobl::Mock >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_assign" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec_assign" "', argument " "2"" of type '" "vector< cosmobl::Mock >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MockVec_assign" "', argument " "3"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec_assign" "', argument " "3"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Mock >::value_type * >(argp3);
  (arg1)->assign(arg2,(vector< cosmobl::Mock >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::size_type arg2 ;
  vector< cosmobl::Mock >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_resize" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec_resize" "', argument " "2"" of type '" "vector< cosmobl::Mock >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MockVec_resize" "', argument " "3"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec_resize" "', argument " "3"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Mock >::value_type * >(argp3);
  (arg1)->resize(arg2,(vector< cosmobl::Mock >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_resize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MockVec_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Mock, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MockVec_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MockVec_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Mock >::resize(vector< cosmobl::Mock >::size_type)\n"
    "    vector< cosmobl::Mock >::resize(vector< cosmobl::Mock >::size_type,vector< cosmobl::Mock >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MockVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::iterator arg2 ;
  vector< cosmobl::Mock >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::Mock >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MockVec_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_insert" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Mock >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Mock >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MockVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Mock >::value_type * >(argp3);
  result = vector_Sl_cosmobl_Mock_Sg__insert__SWIG_0(arg1,arg2,(cosmobl::Mock const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Mock >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::iterator arg2 ;
  vector< cosmobl::Mock >::size_type arg3 ;
  vector< cosmobl::Mock >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MockVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_insert" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Mock >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MockVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Mock >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MockVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Mock >::size_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Mock >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Mock,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MockVec_insert" "', argument " "4"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MockVec_insert" "', argument " "4"" of type '" "vector< cosmobl::Mock >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< vector< cosmobl::Mock >::value_type * >(argp4);
  vector_Sl_cosmobl_Mock_Sg__insert__SWIG_1(arg1,arg2,arg3,(cosmobl::Mock const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_insert(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Mock, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MockVec_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Mock >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Mock, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MockVec_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MockVec_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Mock >::insert(vector< cosmobl::Mock >::iterator,vector< cosmobl::Mock >::value_type const &)\n"
    "    vector< cosmobl::Mock >::insert(vector< cosmobl::Mock >::iterator,vector< cosmobl::Mock >::size_type,vector< cosmobl::Mock >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MockVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  vector< cosmobl::Mock >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MockVec_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_reserve" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MockVec_reserve" "', argument " "2"" of type '" "vector< cosmobl::Mock >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Mock >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MockVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Mock >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MockVec_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MockVec_capacity" "', argument " "1"" of type '" "vector< cosmobl::Mock > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  result = ((vector< cosmobl::Mock > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MockVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Mock > *arg1 = (vector< cosmobl::Mock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MockVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MockVec" "', argument " "1"" of type '" "vector< cosmobl::Mock > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Mock > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MockVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HaloVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_iterator" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (swig::SwigPyIterator *)vector_Sl_cosmobl_Halo_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___nonzero__" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (bool)vector_Sl_cosmobl_Halo_Sg____nonzero__((vector< cosmobl::Halo > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___bool__" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (bool)vector_Sl_cosmobl_Halo_Sg____bool__((vector< cosmobl::Halo > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___len__" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = vector_Sl_cosmobl_Halo_Sg____len__((vector< cosmobl::Halo > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_pop" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  try {
    result = vector_Sl_cosmobl_Halo_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::Halo >::value_type(static_cast< const vector< cosmobl::Halo >::value_type& >(result))), SWIGTYPE_p_cosmobl__Halo, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::difference_type arg2 ;
  vector< cosmobl::Halo >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___getslice__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec___getslice__" "', argument " "2"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HaloVec___getslice__" "', argument " "3"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Halo >::difference_type >(val3);
  try {
    result = (std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *)vector_Sl_cosmobl_Halo_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::difference_type arg2 ;
  vector< cosmobl::Halo >::difference_type arg3 ;
  std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HaloVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HaloVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Halo >::difference_type >(val3);
  {
    std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > > *ptr = (std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HaloVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    vector_Sl_cosmobl_Halo_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::difference_type arg2 ;
  vector< cosmobl::Halo >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HaloVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Halo >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_Halo_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___setslice__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_HaloVec___setslice____SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HaloVec___setslice____SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HaloVec___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Halo >::__setslice__(vector< cosmobl::Halo >::difference_type,vector< cosmobl::Halo >::difference_type,std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &)\n"
    "    vector< cosmobl::Halo >::__setslice__(vector< cosmobl::Halo >::difference_type,vector< cosmobl::Halo >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HaloVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::difference_type arg2 ;
  vector< cosmobl::Halo >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___delslice__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec___delslice__" "', argument " "2"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HaloVec___delslice__" "', argument " "3"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Halo >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_Halo_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec___delitem__" "', argument " "2"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::difference_type >(val2);
  try {
    vector_Sl_cosmobl_Halo_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *)vector_Sl_cosmobl_Halo_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > > *ptr = (std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HaloVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    vector_Sl_cosmobl_Halo_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_Halo_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_Halo_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___delitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HaloVec___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HaloVec___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HaloVec___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Halo >::__delitem__(vector< cosmobl::Halo >::difference_type)\n"
    "    vector< cosmobl::Halo >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HaloVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Halo >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec___getitem__" "', argument " "2"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::difference_type >(val2);
  try {
    result = (vector< cosmobl::Halo >::value_type *) &vector_Sl_cosmobl_Halo_Sg____getitem____SWIG_1((vector< cosmobl::Halo > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___getitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HaloVec___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HaloVec___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HaloVec___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Halo >::__getitem__(PySliceObject *)\n"
    "    vector< cosmobl::Halo >::__getitem__(vector< cosmobl::Halo >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HaloVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::difference_type arg2 ;
  vector< cosmobl::Halo >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec___setitem__" "', argument " "2"" of type '" "vector< cosmobl::Halo >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HaloVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Halo >::value_type * >(argp3);
  try {
    vector_Sl_cosmobl_Halo_Sg____setitem____SWIG_2(arg1,arg2,(cosmobl::Halo const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec___setitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HaloVec___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HaloVec___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Halo, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HaloVec___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HaloVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Halo >::__setitem__(PySliceObject *,std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > const &)\n"
    "    vector< cosmobl::Halo >::__setitem__(PySliceObject *)\n"
    "    vector< cosmobl::Halo >::__setitem__(vector< cosmobl::Halo >::difference_type,vector< cosmobl::Halo >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HaloVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_append" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HaloVec_append" "', argument " "2"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec_append" "', argument " "2"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Halo >::value_type * >(argp2);
  vector_Sl_cosmobl_Halo_Sg__append(arg1,(cosmobl::Halo const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaloVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HaloVec")) SWIG_fail;
  result = (vector< cosmobl::Halo > *)new vector< cosmobl::Halo >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaloVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::Halo > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HaloVec",&obj0)) SWIG_fail;
  {
    std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > > *ptr = (std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HaloVec" "', argument " "1"" of type '" "std::vector< cosmobl::Halo > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HaloVec" "', argument " "1"" of type '" "std::vector< cosmobl::Halo > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (vector< cosmobl::Halo > *)new vector< cosmobl::Halo >((std::vector< cosmobl::Halo > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_empty" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (bool)((vector< cosmobl::Halo > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_size" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = ((vector< cosmobl::Halo > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_clear" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  std::vector< cosmobl::Halo > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_swap" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HaloVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::Halo > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::Halo > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< cosmobl::Halo > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< cosmobl::Halo > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_get_allocator" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = ((vector< cosmobl::Halo > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::Halo >::allocator_type(static_cast< const vector< cosmobl::Halo >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_cosmobl__Halo_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_begin" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Halo >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_end" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Halo >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_rbegin" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Halo >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_rend" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Halo >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaloVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HaloVec",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HaloVec" "', argument " "1"" of type '" "vector< cosmobl::Halo >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::Halo >::size_type >(val1);
  result = (vector< cosmobl::Halo > *)new vector< cosmobl::Halo >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_pop_back" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_resize" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec_resize" "', argument " "2"" of type '" "vector< cosmobl::Halo >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Halo >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_erase" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Halo >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Halo >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_Halo_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Halo >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::iterator arg2 ;
  vector< cosmobl::Halo >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::Halo >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_erase" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Halo >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Halo >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_erase" "', argument " "3"" of type '" "vector< cosmobl::Halo >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_erase" "', argument " "3"" of type '" "vector< cosmobl::Halo >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_Halo_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Halo >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_erase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_HaloVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_HaloVec_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HaloVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Halo >::erase(vector< cosmobl::Halo >::iterator)\n"
    "    vector< cosmobl::Halo >::erase(vector< cosmobl::Halo >::iterator,vector< cosmobl::Halo >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_HaloVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo >::size_type arg1 ;
  vector< cosmobl::Halo >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Halo > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_HaloVec",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HaloVec" "', argument " "1"" of type '" "vector< cosmobl::Halo >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::Halo >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HaloVec" "', argument " "2"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HaloVec" "', argument " "2"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Halo >::value_type * >(argp2);
  result = (vector< cosmobl::Halo > *)new vector< cosmobl::Halo >(arg1,(vector< cosmobl::Halo >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaloVec(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_HaloVec__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_HaloVec__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<cosmobl::Halo,std::allocator< cosmobl::Halo > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HaloVec__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Halo, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_HaloVec__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HaloVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Halo >::vector()\n"
    "    vector< cosmobl::Halo >::vector(std::vector< cosmobl::Halo > const &)\n"
    "    vector< cosmobl::Halo >::vector(vector< cosmobl::Halo >::size_type)\n"
    "    vector< cosmobl::Halo >::vector(vector< cosmobl::Halo >::size_type,vector< cosmobl::Halo >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HaloVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_push_back" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HaloVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Halo >::value_type * >(argp2);
  (arg1)->push_back((vector< cosmobl::Halo >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_front" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (vector< cosmobl::Halo >::value_type *) &((vector< cosmobl::Halo > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_back" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = (vector< cosmobl::Halo >::value_type *) &((vector< cosmobl::Halo > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Halo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::size_type arg2 ;
  vector< cosmobl::Halo >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_assign" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec_assign" "', argument " "2"" of type '" "vector< cosmobl::Halo >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HaloVec_assign" "', argument " "3"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec_assign" "', argument " "3"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Halo >::value_type * >(argp3);
  (arg1)->assign(arg2,(vector< cosmobl::Halo >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::size_type arg2 ;
  vector< cosmobl::Halo >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_resize" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec_resize" "', argument " "2"" of type '" "vector< cosmobl::Halo >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HaloVec_resize" "', argument " "3"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec_resize" "', argument " "3"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Halo >::value_type * >(argp3);
  (arg1)->resize(arg2,(vector< cosmobl::Halo >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_resize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HaloVec_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Halo, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HaloVec_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HaloVec_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Halo >::resize(vector< cosmobl::Halo >::size_type)\n"
    "    vector< cosmobl::Halo >::resize(vector< cosmobl::Halo >::size_type,vector< cosmobl::Halo >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HaloVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::iterator arg2 ;
  vector< cosmobl::Halo >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::Halo >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HaloVec_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_insert" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Halo >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Halo >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HaloVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Halo >::value_type * >(argp3);
  result = vector_Sl_cosmobl_Halo_Sg__insert__SWIG_0(arg1,arg2,(cosmobl::Halo const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Halo >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::iterator arg2 ;
  vector< cosmobl::Halo >::size_type arg3 ;
  vector< cosmobl::Halo >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HaloVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_insert" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Halo >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HaloVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Halo >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HaloVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Halo >::size_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Halo >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Halo,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HaloVec_insert" "', argument " "4"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HaloVec_insert" "', argument " "4"" of type '" "vector< cosmobl::Halo >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< vector< cosmobl::Halo >::value_type * >(argp4);
  vector_Sl_cosmobl_Halo_Sg__insert__SWIG_1(arg1,arg2,arg3,(cosmobl::Halo const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_insert(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Halo, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HaloVec_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Halo >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Halo, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HaloVec_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HaloVec_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Halo >::insert(vector< cosmobl::Halo >::iterator,vector< cosmobl::Halo >::value_type const &)\n"
    "    vector< cosmobl::Halo >::insert(vector< cosmobl::Halo >::iterator,vector< cosmobl::Halo >::size_type,vector< cosmobl::Halo >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HaloVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  vector< cosmobl::Halo >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HaloVec_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_reserve" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HaloVec_reserve" "', argument " "2"" of type '" "vector< cosmobl::Halo >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Halo >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaloVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Halo >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HaloVec_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaloVec_capacity" "', argument " "1"" of type '" "vector< cosmobl::Halo > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  result = ((vector< cosmobl::Halo > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HaloVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Halo > *arg1 = (vector< cosmobl::Halo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HaloVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HaloVec" "', argument " "1"" of type '" "vector< cosmobl::Halo > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Halo > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HaloVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_GalaxyVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_iterator" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (swig::SwigPyIterator *)vector_Sl_cosmobl_Galaxy_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___nonzero__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (bool)vector_Sl_cosmobl_Galaxy_Sg____nonzero__((vector< cosmobl::Galaxy > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___bool__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (bool)vector_Sl_cosmobl_Galaxy_Sg____bool__((vector< cosmobl::Galaxy > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___len__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = vector_Sl_cosmobl_Galaxy_Sg____len__((vector< cosmobl::Galaxy > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_pop" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  try {
    result = vector_Sl_cosmobl_Galaxy_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::Galaxy >::value_type(static_cast< const vector< cosmobl::Galaxy >::value_type& >(result))), SWIGTYPE_p_cosmobl__Galaxy, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::difference_type arg2 ;
  vector< cosmobl::Galaxy >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___getslice__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec___getslice__" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GalaxyVec___getslice__" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val3);
  try {
    result = (std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *)vector_Sl_cosmobl_Galaxy_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::difference_type arg2 ;
  vector< cosmobl::Galaxy >::difference_type arg3 ;
  std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:GalaxyVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GalaxyVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val3);
  {
    std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *ptr = (std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GalaxyVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    vector_Sl_cosmobl_Galaxy_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::difference_type arg2 ;
  vector< cosmobl::Galaxy >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GalaxyVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_Galaxy_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___setslice__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GalaxyVec___setslice____SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_GalaxyVec___setslice____SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GalaxyVec___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Galaxy >::__setslice__(vector< cosmobl::Galaxy >::difference_type,vector< cosmobl::Galaxy >::difference_type,std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &)\n"
    "    vector< cosmobl::Galaxy >::__setslice__(vector< cosmobl::Galaxy >::difference_type,vector< cosmobl::Galaxy >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::difference_type arg2 ;
  vector< cosmobl::Galaxy >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___delslice__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec___delslice__" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GalaxyVec___delslice__" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_Galaxy_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec___delitem__" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val2);
  try {
    vector_Sl_cosmobl_Galaxy_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *)vector_Sl_cosmobl_Galaxy_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *ptr = (std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GalaxyVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    vector_Sl_cosmobl_Galaxy_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_Galaxy_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_Galaxy_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___delitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_GalaxyVec___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GalaxyVec___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GalaxyVec___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Galaxy >::__delitem__(vector< cosmobl::Galaxy >::difference_type)\n"
    "    vector< cosmobl::Galaxy >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Galaxy >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec___getitem__" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val2);
  try {
    result = (vector< cosmobl::Galaxy >::value_type *) &vector_Sl_cosmobl_Galaxy_Sg____getitem____SWIG_1((vector< cosmobl::Galaxy > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___getitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_GalaxyVec___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GalaxyVec___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GalaxyVec___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Galaxy >::__getitem__(PySliceObject *)\n"
    "    vector< cosmobl::Galaxy >::__getitem__(vector< cosmobl::Galaxy >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::difference_type arg2 ;
  vector< cosmobl::Galaxy >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec___setitem__" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GalaxyVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Galaxy >::value_type * >(argp3);
  try {
    vector_Sl_cosmobl_Galaxy_Sg____setitem____SWIG_2(arg1,arg2,(cosmobl::Galaxy const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec___setitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_GalaxyVec___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GalaxyVec___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Galaxy, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GalaxyVec___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GalaxyVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Galaxy >::__setitem__(PySliceObject *,std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > const &)\n"
    "    vector< cosmobl::Galaxy >::__setitem__(PySliceObject *)\n"
    "    vector< cosmobl::Galaxy >::__setitem__(vector< cosmobl::Galaxy >::difference_type,vector< cosmobl::Galaxy >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_append" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GalaxyVec_append" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec_append" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Galaxy >::value_type * >(argp2);
  vector_Sl_cosmobl_Galaxy_Sg__append(arg1,(cosmobl::Galaxy const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GalaxyVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GalaxyVec")) SWIG_fail;
  result = (vector< cosmobl::Galaxy > *)new vector< cosmobl::Galaxy >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GalaxyVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::Galaxy > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GalaxyVec",&obj0)) SWIG_fail;
  {
    std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *ptr = (std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GalaxyVec" "', argument " "1"" of type '" "std::vector< cosmobl::Galaxy > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GalaxyVec" "', argument " "1"" of type '" "std::vector< cosmobl::Galaxy > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (vector< cosmobl::Galaxy > *)new vector< cosmobl::Galaxy >((std::vector< cosmobl::Galaxy > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_empty" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (bool)((vector< cosmobl::Galaxy > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_size" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = ((vector< cosmobl::Galaxy > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_clear" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  std::vector< cosmobl::Galaxy > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_swap" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GalaxyVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::Galaxy > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::Galaxy > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< cosmobl::Galaxy > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< cosmobl::Galaxy > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_get_allocator" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = ((vector< cosmobl::Galaxy > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::Galaxy >::allocator_type(static_cast< const vector< cosmobl::Galaxy >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_cosmobl__Galaxy_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_begin" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Galaxy >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_end" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Galaxy >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_rbegin" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Galaxy >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_rend" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Galaxy >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GalaxyVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GalaxyVec",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GalaxyVec" "', argument " "1"" of type '" "vector< cosmobl::Galaxy >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::Galaxy >::size_type >(val1);
  result = (vector< cosmobl::Galaxy > *)new vector< cosmobl::Galaxy >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_pop_back" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_resize" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec_resize" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Galaxy >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_erase" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_Galaxy_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Galaxy >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::iterator arg2 ;
  vector< cosmobl::Galaxy >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::Galaxy >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_erase" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_erase" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_erase" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_Galaxy_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Galaxy >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_erase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_GalaxyVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_GalaxyVec_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GalaxyVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Galaxy >::erase(vector< cosmobl::Galaxy >::iterator)\n"
    "    vector< cosmobl::Galaxy >::erase(vector< cosmobl::Galaxy >::iterator,vector< cosmobl::Galaxy >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_GalaxyVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy >::size_type arg1 ;
  vector< cosmobl::Galaxy >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Galaxy > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_GalaxyVec",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GalaxyVec" "', argument " "1"" of type '" "vector< cosmobl::Galaxy >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::Galaxy >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GalaxyVec" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GalaxyVec" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Galaxy >::value_type * >(argp2);
  result = (vector< cosmobl::Galaxy > *)new vector< cosmobl::Galaxy >(arg1,(vector< cosmobl::Galaxy >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GalaxyVec(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_GalaxyVec__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GalaxyVec__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GalaxyVec__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Galaxy, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GalaxyVec__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GalaxyVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Galaxy >::vector()\n"
    "    vector< cosmobl::Galaxy >::vector(std::vector< cosmobl::Galaxy > const &)\n"
    "    vector< cosmobl::Galaxy >::vector(vector< cosmobl::Galaxy >::size_type)\n"
    "    vector< cosmobl::Galaxy >::vector(vector< cosmobl::Galaxy >::size_type,vector< cosmobl::Galaxy >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_push_back" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GalaxyVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Galaxy >::value_type * >(argp2);
  (arg1)->push_back((vector< cosmobl::Galaxy >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_front" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (vector< cosmobl::Galaxy >::value_type *) &((vector< cosmobl::Galaxy > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_back" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = (vector< cosmobl::Galaxy >::value_type *) &((vector< cosmobl::Galaxy > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Galaxy, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::size_type arg2 ;
  vector< cosmobl::Galaxy >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_assign" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec_assign" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GalaxyVec_assign" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec_assign" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Galaxy >::value_type * >(argp3);
  (arg1)->assign(arg2,(vector< cosmobl::Galaxy >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::size_type arg2 ;
  vector< cosmobl::Galaxy >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_resize" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec_resize" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GalaxyVec_resize" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec_resize" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Galaxy >::value_type * >(argp3);
  (arg1)->resize(arg2,(vector< cosmobl::Galaxy >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_resize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GalaxyVec_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Galaxy, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GalaxyVec_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GalaxyVec_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Galaxy >::resize(vector< cosmobl::Galaxy >::size_type)\n"
    "    vector< cosmobl::Galaxy >::resize(vector< cosmobl::Galaxy >::size_type,vector< cosmobl::Galaxy >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::iterator arg2 ;
  vector< cosmobl::Galaxy >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::Galaxy >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GalaxyVec_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_insert" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GalaxyVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Galaxy >::value_type * >(argp3);
  result = vector_Sl_cosmobl_Galaxy_Sg__insert__SWIG_0(arg1,arg2,(cosmobl::Galaxy const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Galaxy >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::iterator arg2 ;
  vector< cosmobl::Galaxy >::size_type arg3 ;
  vector< cosmobl::Galaxy >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:GalaxyVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_insert" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GalaxyVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GalaxyVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Galaxy >::size_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Galaxy >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Galaxy,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GalaxyVec_insert" "', argument " "4"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GalaxyVec_insert" "', argument " "4"" of type '" "vector< cosmobl::Galaxy >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< vector< cosmobl::Galaxy >::value_type * >(argp4);
  vector_Sl_cosmobl_Galaxy_Sg__insert__SWIG_1(arg1,arg2,arg3,(cosmobl::Galaxy const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_insert(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Galaxy, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GalaxyVec_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Galaxy >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Galaxy, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_GalaxyVec_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GalaxyVec_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Galaxy >::insert(vector< cosmobl::Galaxy >::iterator,vector< cosmobl::Galaxy >::value_type const &)\n"
    "    vector< cosmobl::Galaxy >::insert(vector< cosmobl::Galaxy >::iterator,vector< cosmobl::Galaxy >::size_type,vector< cosmobl::Galaxy >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  vector< cosmobl::Galaxy >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GalaxyVec_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_reserve" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GalaxyVec_reserve" "', argument " "2"" of type '" "vector< cosmobl::Galaxy >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Galaxy >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GalaxyVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Galaxy >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GalaxyVec_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GalaxyVec_capacity" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  result = ((vector< cosmobl::Galaxy > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GalaxyVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Galaxy > *arg1 = (vector< cosmobl::Galaxy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GalaxyVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GalaxyVec" "', argument " "1"" of type '" "vector< cosmobl::Galaxy > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Galaxy > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GalaxyVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ClusterVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_iterator" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (swig::SwigPyIterator *)vector_Sl_cosmobl_Cluster_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___nonzero__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (bool)vector_Sl_cosmobl_Cluster_Sg____nonzero__((vector< cosmobl::Cluster > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___bool__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (bool)vector_Sl_cosmobl_Cluster_Sg____bool__((vector< cosmobl::Cluster > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___len__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = vector_Sl_cosmobl_Cluster_Sg____len__((vector< cosmobl::Cluster > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_pop" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  try {
    result = vector_Sl_cosmobl_Cluster_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::Cluster >::value_type(static_cast< const vector< cosmobl::Cluster >::value_type& >(result))), SWIGTYPE_p_cosmobl__Cluster, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::difference_type arg2 ;
  vector< cosmobl::Cluster >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___getslice__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec___getslice__" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ClusterVec___getslice__" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Cluster >::difference_type >(val3);
  try {
    result = (std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *)vector_Sl_cosmobl_Cluster_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::difference_type arg2 ;
  vector< cosmobl::Cluster >::difference_type arg3 ;
  std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ClusterVec___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ClusterVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Cluster >::difference_type >(val3);
  {
    std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *ptr = (std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ClusterVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec___setslice__" "', argument " "4"" of type '" "std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    vector_Sl_cosmobl_Cluster_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::difference_type arg2 ;
  vector< cosmobl::Cluster >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___setslice__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec___setslice__" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ClusterVec___setslice__" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Cluster >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_Cluster_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___setslice__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ClusterVec___setslice____SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ClusterVec___setslice____SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ClusterVec___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Cluster >::__setslice__(vector< cosmobl::Cluster >::difference_type,vector< cosmobl::Cluster >::difference_type,std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &)\n"
    "    vector< cosmobl::Cluster >::__setslice__(vector< cosmobl::Cluster >::difference_type,vector< cosmobl::Cluster >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterVec___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::difference_type arg2 ;
  vector< cosmobl::Cluster >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___delslice__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec___delslice__" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ClusterVec___delslice__" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Cluster >::difference_type >(val3);
  try {
    vector_Sl_cosmobl_Cluster_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec___delitem__" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::difference_type >(val2);
  try {
    vector_Sl_cosmobl_Cluster_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *)vector_Sl_cosmobl_Cluster_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *ptr = (std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ClusterVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec___setitem__" "', argument " "3"" of type '" "std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    vector_Sl_cosmobl_Cluster_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_Cluster_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___delitem__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    vector_Sl_cosmobl_Cluster_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___delitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ClusterVec___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ClusterVec___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ClusterVec___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Cluster >::__delitem__(vector< cosmobl::Cluster >::difference_type)\n"
    "    vector< cosmobl::Cluster >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterVec___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Cluster >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___getitem__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec___getitem__" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::difference_type >(val2);
  try {
    result = (vector< cosmobl::Cluster >::value_type *) &vector_Sl_cosmobl_Cluster_Sg____getitem____SWIG_1((vector< cosmobl::Cluster > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___getitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ClusterVec___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ClusterVec___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ClusterVec___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Cluster >::__getitem__(PySliceObject *)\n"
    "    vector< cosmobl::Cluster >::__getitem__(vector< cosmobl::Cluster >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterVec___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::difference_type arg2 ;
  vector< cosmobl::Cluster >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec___setitem__" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec___setitem__" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::difference_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ClusterVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec___setitem__" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Cluster >::value_type * >(argp3);
  try {
    vector_Sl_cosmobl_Cluster_Sg____setitem____SWIG_2(arg1,arg2,(cosmobl::Cluster const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec___setitem__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ClusterVec___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ClusterVec___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Cluster, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ClusterVec___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ClusterVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Cluster >::__setitem__(PySliceObject *,std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > const &)\n"
    "    vector< cosmobl::Cluster >::__setitem__(PySliceObject *)\n"
    "    vector< cosmobl::Cluster >::__setitem__(vector< cosmobl::Cluster >::difference_type,vector< cosmobl::Cluster >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterVec_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_append" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClusterVec_append" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec_append" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Cluster >::value_type * >(argp2);
  vector_Sl_cosmobl_Cluster_Sg__append(arg1,(cosmobl::Cluster const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClusterVec")) SWIG_fail;
  result = (vector< cosmobl::Cluster > *)new vector< cosmobl::Cluster >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< cosmobl::Cluster > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClusterVec",&obj0)) SWIG_fail;
  {
    std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *ptr = (std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClusterVec" "', argument " "1"" of type '" "std::vector< cosmobl::Cluster > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClusterVec" "', argument " "1"" of type '" "std::vector< cosmobl::Cluster > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (vector< cosmobl::Cluster > *)new vector< cosmobl::Cluster >((std::vector< cosmobl::Cluster > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_empty" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (bool)((vector< cosmobl::Cluster > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_size" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = ((vector< cosmobl::Cluster > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_clear" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  std::vector< cosmobl::Cluster > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_swap" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClusterVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::Cluster > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec_swap" "', argument " "2"" of type '" "std::vector< cosmobl::Cluster > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< cosmobl::Cluster > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< cosmobl::Cluster > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_get_allocator" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = ((vector< cosmobl::Cluster > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new vector< cosmobl::Cluster >::allocator_type(static_cast< const vector< cosmobl::Cluster >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_cosmobl__Cluster_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_begin" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Cluster >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_end" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Cluster >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_rbegin" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Cluster >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_rend" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Cluster >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClusterVec",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClusterVec" "', argument " "1"" of type '" "vector< cosmobl::Cluster >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::Cluster >::size_type >(val1);
  result = (vector< cosmobl::Cluster > *)new vector< cosmobl::Cluster >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_pop_back" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_resize" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec_resize" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Cluster >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_erase" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_Cluster_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Cluster >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::iterator arg2 ;
  vector< cosmobl::Cluster >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::Cluster >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_erase" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_erase" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_erase" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_erase" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::iterator""'");
    }
  }
  result = vector_Sl_cosmobl_Cluster_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Cluster >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_erase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_ClusterVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_ClusterVec_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ClusterVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Cluster >::erase(vector< cosmobl::Cluster >::iterator)\n"
    "    vector< cosmobl::Cluster >::erase(vector< cosmobl::Cluster >::iterator,vector< cosmobl::Cluster >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ClusterVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster >::size_type arg1 ;
  vector< cosmobl::Cluster >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  vector< cosmobl::Cluster > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ClusterVec",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClusterVec" "', argument " "1"" of type '" "vector< cosmobl::Cluster >::size_type""'");
  } 
  arg1 = static_cast< vector< cosmobl::Cluster >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ClusterVec" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClusterVec" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Cluster >::value_type * >(argp2);
  result = (vector< cosmobl::Cluster > *)new vector< cosmobl::Cluster >(arg1,(vector< cosmobl::Cluster >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterVec(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ClusterVec__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ClusterVec__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<cosmobl::Cluster,std::allocator< cosmobl::Cluster > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClusterVec__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cluster, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ClusterVec__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClusterVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Cluster >::vector()\n"
    "    vector< cosmobl::Cluster >::vector(std::vector< cosmobl::Cluster > const &)\n"
    "    vector< cosmobl::Cluster >::vector(vector< cosmobl::Cluster >::size_type)\n"
    "    vector< cosmobl::Cluster >::vector(vector< cosmobl::Cluster >::size_type,vector< cosmobl::Cluster >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterVec_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_push_back" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClusterVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec_push_back" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< vector< cosmobl::Cluster >::value_type * >(argp2);
  (arg1)->push_back((vector< cosmobl::Cluster >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_front" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (vector< cosmobl::Cluster >::value_type *) &((vector< cosmobl::Cluster > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_back" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = (vector< cosmobl::Cluster >::value_type *) &((vector< cosmobl::Cluster > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cluster, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::size_type arg2 ;
  vector< cosmobl::Cluster >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_assign" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec_assign" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ClusterVec_assign" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec_assign" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Cluster >::value_type * >(argp3);
  (arg1)->assign(arg2,(vector< cosmobl::Cluster >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::size_type arg2 ;
  vector< cosmobl::Cluster >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_resize" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec_resize" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ClusterVec_resize" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec_resize" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Cluster >::value_type * >(argp3);
  (arg1)->resize(arg2,(vector< cosmobl::Cluster >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_resize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ClusterVec_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Cluster, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ClusterVec_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ClusterVec_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Cluster >::resize(vector< cosmobl::Cluster >::size_type)\n"
    "    vector< cosmobl::Cluster >::resize(vector< cosmobl::Cluster >::size_type,vector< cosmobl::Cluster >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterVec_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::iterator arg2 ;
  vector< cosmobl::Cluster >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  vector< cosmobl::Cluster >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ClusterVec_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_insert" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ClusterVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< vector< cosmobl::Cluster >::value_type * >(argp3);
  result = vector_Sl_cosmobl_Cluster_Sg__insert__SWIG_0(arg1,arg2,(cosmobl::Cluster const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< cosmobl::Cluster >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::iterator arg2 ;
  vector< cosmobl::Cluster >::size_type arg3 ;
  vector< cosmobl::Cluster >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ClusterVec_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_insert" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::iterator""'");
  } else {
    swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ClusterVec_insert" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ClusterVec_insert" "', argument " "3"" of type '" "vector< cosmobl::Cluster >::size_type""'");
  } 
  arg3 = static_cast< vector< cosmobl::Cluster >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cluster,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ClusterVec_insert" "', argument " "4"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterVec_insert" "', argument " "4"" of type '" "vector< cosmobl::Cluster >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< vector< cosmobl::Cluster >::value_type * >(argp4);
  vector_Sl_cosmobl_Cluster_Sg__insert__SWIG_1(arg1,arg2,arg3,(cosmobl::Cluster const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_insert(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Cluster, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ClusterVec_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<vector< cosmobl::Cluster >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cluster, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ClusterVec_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ClusterVec_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vector< cosmobl::Cluster >::insert(vector< cosmobl::Cluster >::iterator,vector< cosmobl::Cluster >::value_type const &)\n"
    "    vector< cosmobl::Cluster >::insert(vector< cosmobl::Cluster >::iterator,vector< cosmobl::Cluster >::size_type,vector< cosmobl::Cluster >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterVec_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  vector< cosmobl::Cluster >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterVec_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_reserve" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterVec_reserve" "', argument " "2"" of type '" "vector< cosmobl::Cluster >::size_type""'");
  } 
  arg2 = static_cast< vector< cosmobl::Cluster >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterVec_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  vector< cosmobl::Cluster >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterVec_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterVec_capacity" "', argument " "1"" of type '" "vector< cosmobl::Cluster > const *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  result = ((vector< cosmobl::Cluster > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ClusterVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  vector< cosmobl::Cluster > *arg1 = (vector< cosmobl::Cluster > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClusterVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClusterVec" "', argument " "1"" of type '" "vector< cosmobl::Cluster > *""'"); 
  }
  arg1 = reinterpret_cast< vector< cosmobl::Cluster > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ClusterVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ObjectPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  shared_ptr< cosmobl::Object > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ObjectPtr")) SWIG_fail;
  result = (shared_ptr< cosmobl::Object > *)new shared_ptr< cosmobl::Object >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ObjectPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  shared_ptr< cosmobl::Object > *arg1 = (shared_ptr< cosmobl::Object > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ObjectPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ObjectPtr" "', argument " "1"" of type '" "shared_ptr< cosmobl::Object > *""'"); 
  }
  arg1 = reinterpret_cast< shared_ptr< cosmobl::Object > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ObjectPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LogNormal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LogNormal")) SWIG_fail;
  result = (cosmobl::LogNormal *)new cosmobl::LogNormal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__LogNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LogNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LogNormal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNormal" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::LogNormal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LogNormal",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormal" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormal" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormal" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormal" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogNormal" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (cosmobl::LogNormal *)new cosmobl::LogNormal(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__LogNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormal(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LogNormal__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LogNormal__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LogNormal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::LogNormal::LogNormal()\n"
    "    cosmobl::LogNormal::LogNormal(std::shared_ptr< cosmobl::Catalogue > const,std::shared_ptr< cosmobl::Catalogue > const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogNormal_setCatalogues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LogNormal_setCatalogues",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_setCatalogues" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogNormal_setCatalogues" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setCatalogues" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LogNormal_setCatalogues" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setCatalogues" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->setCatalogues(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_setParameters_from_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LogNormal_setParameters_from_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_setParameters_from_xi" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogNormal_setParameters_from_xi" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setParameters_from_xi" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LogNormal_setParameters_from_xi" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setParameters_from_xi" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->setParameters_from_xi(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_setParameters_from_model__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Cosmology > > arg2 ;
  double arg3 ;
  bool arg4 ;
  std::string arg5 ;
  bool arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:LogNormal_setParameters_from_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_setParameters_from_model" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'");
    } else {
      std::shared_ptr< cosmobl::Cosmology > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Cosmology > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogNormal_setParameters_from_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LogNormal_setParameters_from_model" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LogNormal_setParameters_from_model" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LogNormal_setParameters_from_model" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LogNormal_setParameters_from_model" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setParameters_from_model(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_setParameters_from_model__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Cosmology > > arg2 ;
  double arg3 ;
  bool arg4 ;
  std::string arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:LogNormal_setParameters_from_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_setParameters_from_model" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'");
    } else {
      std::shared_ptr< cosmobl::Cosmology > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Cosmology > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogNormal_setParameters_from_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LogNormal_setParameters_from_model" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LogNormal_setParameters_from_model" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LogNormal_setParameters_from_model" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->setParameters_from_model(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_setParameters_from_model__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Cosmology > > arg2 ;
  double arg3 ;
  bool arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LogNormal_setParameters_from_model",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_setParameters_from_model" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'");
    } else {
      std::shared_ptr< cosmobl::Cosmology > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Cosmology > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogNormal_setParameters_from_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LogNormal_setParameters_from_model" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LogNormal_setParameters_from_model" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setParameters_from_model(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_setParameters_from_model__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Cosmology > > arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LogNormal_setParameters_from_model",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_setParameters_from_model" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'");
    } else {
      std::shared_ptr< cosmobl::Cosmology > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Cosmology > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogNormal_setParameters_from_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LogNormal_setParameters_from_model" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->setParameters_from_model(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_setParameters_from_model__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Cosmology > > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LogNormal_setParameters_from_model",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_setParameters_from_model" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogNormal_setParameters_from_model" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Cosmology > const""'");
    } else {
      std::shared_ptr< cosmobl::Cosmology > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Cosmology > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogNormal_setParameters_from_model" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setParameters_from_model(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_setParameters_from_model(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__LogNormal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogNormal_setParameters_from_model__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__LogNormal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LogNormal_setParameters_from_model__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__LogNormal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_LogNormal_setParameters_from_model__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__LogNormal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_LogNormal_setParameters_from_model__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__LogNormal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Cosmology_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_LogNormal_setParameters_from_model__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogNormal_setParameters_from_model'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::LogNormal::setParameters_from_model(std::shared_ptr< cosmobl::Cosmology > const,double const,bool const,std::string const,bool const,std::string const)\n"
    "    cosmobl::LogNormal::setParameters_from_model(std::shared_ptr< cosmobl::Cosmology > const,double const,bool const,std::string const,bool const)\n"
    "    cosmobl::LogNormal::setParameters_from_model(std::shared_ptr< cosmobl::Cosmology > const,double const,bool const,std::string const)\n"
    "    cosmobl::LogNormal::setParameters_from_model(std::shared_ptr< cosmobl::Cosmology > const,double const,bool const)\n"
    "    cosmobl::LogNormal::setParameters_from_model(std::shared_ptr< cosmobl::Cosmology > const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogNormal_set_nLN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LogNormal_set_nLN",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_set_nLN" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogNormal_set_nLN" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nLN(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_nLN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LogNormal_nLN",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_nLN" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  result = (int)(arg1)->nLN();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_LNCat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LogNormal_LNCat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_LNCat" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogNormal_LNCat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->LNCat(arg2);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_generate_LogNormal_mock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  double arg2 ;
  std::string arg3 ;
  int arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LogNormal_generate_LogNormal_mock",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->generate_LogNormal_mock(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_generate_LogNormal_mock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  double arg2 ;
  std::string arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LogNormal_generate_LogNormal_mock",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->generate_LogNormal_mock(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_generate_LogNormal_mock__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::LogNormal *arg1 = (cosmobl::LogNormal *) 0 ;
  double arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LogNormal_generate_LogNormal_mock",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__LogNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "1"" of type '" "cosmobl::LogNormal *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::LogNormal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LogNormal_generate_LogNormal_mock" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->generate_LogNormal_mock(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogNormal_generate_LogNormal_mock(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__LogNormal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LogNormal_generate_LogNormal_mock__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__LogNormal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LogNormal_generate_LogNormal_mock__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__LogNormal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_LogNormal_generate_LogNormal_mock__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogNormal_generate_LogNormal_mock'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::LogNormal::generate_LogNormal_mock(double const,std::string const,int const,std::string const)\n"
    "    cosmobl::LogNormal::generate_LogNormal_mock(double const,std::string const,int const)\n"
    "    cosmobl::LogNormal::generate_LogNormal_mock(double const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *LogNormal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__LogNormal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_random_catalogue_fromFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::string > > arg1 ;
  double arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:random_catalogue_fromFile",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_catalogue_fromFile" "', argument " "1"" of type '" "std::vector< std::string > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_fromFile" "', argument " "1"" of type '" "std::vector< std::string > const""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_catalogue_fromFile" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = cosmobl::random_catalogue_fromFile(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_fromFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< std::string > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:random_catalogue_fromFile",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_catalogue_fromFile" "', argument " "1"" of type '" "std::vector< std::string > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_fromFile" "', argument " "1"" of type '" "std::vector< std::string > const""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = cosmobl::random_catalogue_fromFile(arg1);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_fromFile(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_random_catalogue_fromFile__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_random_catalogue_fromFile__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'random_catalogue_fromFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::random_catalogue_fromFile(std::vector< std::string > const,double const)\n"
    "    cosmobl::random_catalogue_fromFile(std::vector< std::string > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_random_catalogue_radecred_fromFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double arg6 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:random_catalogue_radecred_fromFile",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_radecred_fromFile" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_catalogue_radecred_fromFile" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "random_catalogue_radecred_fromFile" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "random_catalogue_radecred_fromFile" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_radecred_fromFile" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "random_catalogue_radecred_fromFile" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "random_catalogue_radecred_fromFile" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = cosmobl::random_catalogue_radecred_fromFile(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_radecred_fromFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double arg5 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:random_catalogue_radecred_fromFile",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_radecred_fromFile" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_catalogue_radecred_fromFile" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "random_catalogue_radecred_fromFile" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "random_catalogue_radecred_fromFile" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_radecred_fromFile" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "random_catalogue_radecred_fromFile" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = cosmobl::random_catalogue_radecred_fromFile(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_radecred_fromFile__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:random_catalogue_radecred_fromFile",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_radecred_fromFile" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_catalogue_radecred_fromFile" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "random_catalogue_radecred_fromFile" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "random_catalogue_radecred_fromFile" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_radecred_fromFile" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  result = cosmobl::random_catalogue_radecred_fromFile(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_radecred_fromFile(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_random_catalogue_radecred_fromFile__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_random_catalogue_radecred_fromFile__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_random_catalogue_radecred_fromFile__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'random_catalogue_radecred_fromFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::random_catalogue_radecred_fromFile(std::string const,double const,double const,cosmobl::Cosmology const &,double const,double const)\n"
    "    cosmobl::random_catalogue_radecred_fromFile(std::string const,double const,double const,cosmobl::Cosmology const &,double const)\n"
    "    cosmobl::random_catalogue_radecred_fromFile(std::string const,double const,double const,cosmobl::Cosmology const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_random_catalogue_box(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:random_catalogue_box",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_catalogue_box" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_box" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_catalogue_box" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = cosmobl::random_catalogue_box(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_warped_random_catalogue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Cosmology *arg1 = 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string arg3 ;
  std::string arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:warped_random_catalogue",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "warped_random_catalogue" "', argument " "1"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "warped_random_catalogue" "', argument " "1"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Cosmology * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "warped_random_catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "warped_random_catalogue" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "warped_random_catalogue" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "warped_random_catalogue" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "warped_random_catalogue" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "warped_random_catalogue" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = cosmobl::warped_random_catalogue((cosmobl::Cosmology const &)*arg1,(cosmobl::Cosmology const &)*arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_cone__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  int arg2 ;
  cosmobl::Cosmology *arg3 = 0 ;
  double arg4 ;
  int arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  std::vector< double > *arg7 = 0 ;
  std::vector< double > *arg8 = 0 ;
  int arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:random_catalogue_cone",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_catalogue_cone" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_catalogue_cone" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "random_catalogue_cone" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "random_catalogue_cone" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "random_catalogue_cone" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "random_catalogue_cone" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "random_catalogue_cone" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "random_catalogue_cone" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  arg8 = reinterpret_cast< std::vector< double > * >(argp8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "random_catalogue_cone" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = cosmobl::random_catalogue_cone(arg1,arg2,(cosmobl::Cosmology const &)*arg3,arg4,arg5,arg6,*arg7,*arg8,arg9);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_cone__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  int arg2 ;
  cosmobl::Cosmology *arg3 = 0 ;
  double arg4 ;
  int arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  std::vector< double > *arg7 = 0 ;
  std::vector< double > *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:random_catalogue_cone",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_catalogue_cone" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_catalogue_cone" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "random_catalogue_cone" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "random_catalogue_cone" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "random_catalogue_cone" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "random_catalogue_cone" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "random_catalogue_cone" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "random_catalogue_cone" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_cone" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  arg8 = reinterpret_cast< std::vector< double > * >(argp8);
  result = cosmobl::random_catalogue_cone(arg1,arg2,(cosmobl::Cosmology const &)*arg3,arg4,arg5,arg6,*arg7,*arg8);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_cone(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 8) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_random_catalogue_cone__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_random_catalogue_cone__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'random_catalogue_cone'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::random_catalogue_cone(std::shared_ptr< cosmobl::Catalogue > const,int const,cosmobl::Cosmology const &,double const,int const,std::vector< double > const,std::vector< double > &,std::vector< double > &,int const)\n"
    "    cosmobl::random_catalogue_cone(std::shared_ptr< cosmobl::Catalogue > const,int const,cosmobl::Cosmology const &,double const,int const,std::vector< double > const,std::vector< double > &,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_random_catalogue_mock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  int *arg2 = 0 ;
  cosmobl::Cosmology *arg3 = 0 ;
  std::string *arg4 = 0 ;
  int *arg5 = 0 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  std::vector< double > *arg7 = 0 ;
  std::vector< double > *arg8 = 0 ;
  int arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:random_catalogue_mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_catalogue_mock" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_catalogue_mock" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "random_catalogue_mock" "', argument " "3"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "3"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "random_catalogue_mock" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "random_catalogue_mock" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "random_catalogue_mock" "', argument " "6"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "6"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "random_catalogue_mock" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "random_catalogue_mock" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  arg8 = reinterpret_cast< std::vector< double > * >(argp8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "random_catalogue_mock" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = cosmobl::random_catalogue_mock(arg1,*arg2,*arg3,*arg4,*arg5,arg6,*arg7,*arg8,arg9);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_mock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  int *arg2 = 0 ;
  cosmobl::Cosmology *arg3 = 0 ;
  std::string *arg4 = 0 ;
  int *arg5 = 0 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  std::vector< double > *arg7 = 0 ;
  std::vector< double > *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:random_catalogue_mock",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_catalogue_mock" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_catalogue_mock" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "random_catalogue_mock" "', argument " "3"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "3"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "random_catalogue_mock" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "random_catalogue_mock" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "random_catalogue_mock" "', argument " "6"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "6"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "random_catalogue_mock" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "random_catalogue_mock" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock" "', argument " "8"" of type '" "std::vector< double > &""'"); 
  }
  arg8 = reinterpret_cast< std::vector< double > * >(argp8);
  result = cosmobl::random_catalogue_mock(arg1,*arg2,*arg3,*arg4,*arg5,arg6,*arg7,*arg8);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_mock(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 8) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_random_catalogue_mock__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_random_catalogue_mock__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'random_catalogue_mock'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::random_catalogue_mock(std::shared_ptr< cosmobl::Catalogue >,int &,cosmobl::Cosmology &,std::string &,int &,std::vector< double >,std::vector< double > &,std::vector< double > &,int)\n"
    "    cosmobl::random_catalogue_mock(std::shared_ptr< cosmobl::Catalogue >,int &,cosmobl::Cosmology &,std::string &,int &,std::vector< double >,std::vector< double > &,std::vector< double > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_random_redshift_distribution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  std::string arg3 ;
  int arg4 ;
  bool arg5 ;
  double arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:random_redshift_distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_redshift_distribution" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_redshift_distribution" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_redshift_distribution" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_redshift_distribution" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_redshift_distribution" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "random_redshift_distribution" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "random_redshift_distribution" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "random_redshift_distribution" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  cosmobl::random_redshift_distribution(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_mock_cone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  int arg2 ;
  cosmobl::Cosmology *arg3 = 0 ;
  std::string arg4 ;
  int arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:random_catalogue_mock_cone",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_catalogue_mock_cone" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock_cone" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_catalogue_mock_cone" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "random_catalogue_mock_cone" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock_cone" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_mock_cone" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "random_catalogue_mock_cone" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "random_catalogue_mock_cone" "', argument " "6"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_mock_cone" "', argument " "6"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  result = cosmobl::random_catalogue_mock_cone(arg1,arg2,(cosmobl::Cosmology const &)*arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_VIPERS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string arg3 ;
  int arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  bool arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  std::string arg12 ;
  int arg13 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:random_catalogue_VIPERS",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_catalogue_VIPERS" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_catalogue_VIPERS" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_VIPERS" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "random_catalogue_VIPERS" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "random_catalogue_VIPERS" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "random_catalogue_VIPERS" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "random_catalogue_VIPERS" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "random_catalogue_VIPERS" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "random_catalogue_VIPERS" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_VIPERS" "', argument " "10"" of type '" "std::string""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_VIPERS" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_VIPERS" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "random_catalogue_VIPERS" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  result = cosmobl::random_catalogue_VIPERS(arg1,(cosmobl::Cosmology const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_VIPERS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string arg3 ;
  int arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  bool arg9 ;
  std::string arg10 ;
  std::string arg11 ;
  std::string arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:random_catalogue_VIPERS",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_catalogue_VIPERS" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_catalogue_VIPERS" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_VIPERS" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "random_catalogue_VIPERS" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "random_catalogue_VIPERS" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "random_catalogue_VIPERS" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "random_catalogue_VIPERS" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "random_catalogue_VIPERS" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_catalogue_VIPERS" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "random_catalogue_VIPERS" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_VIPERS" "', argument " "10"" of type '" "std::string""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj10, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_VIPERS" "', argument " "11"" of type '" "std::string const""'"); 
    }
    arg11 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_catalogue_VIPERS" "', argument " "12"" of type '" "std::string const""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = cosmobl::random_catalogue_VIPERS(arg1,(cosmobl::Cosmology const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_catalogue_VIPERS(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[14] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 13) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_random_catalogue_VIPERS__SWIG_1(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_random_catalogue_VIPERS__SWIG_0(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'random_catalogue_VIPERS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::random_catalogue_VIPERS(int const,cosmobl::Cosmology const &,std::string const,int const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,bool const,std::string,std::string const,std::string const,int const)\n"
    "    cosmobl::random_catalogue_VIPERS(int const,cosmobl::Cosmology const &,std::string const,int const,std::vector< double > const,std::vector< double > const,std::vector< double > const,std::vector< double > const,bool const,std::string,std::string const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_random_sdss_angular_distribution__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:random_sdss_angular_distribution",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_sdss_angular_distribution" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_sdss_angular_distribution" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_sdss_angular_distribution" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "random_sdss_angular_distribution" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = cosmobl::random_sdss_angular_distribution(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_sdss_angular_distribution__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:random_sdss_angular_distribution",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_sdss_angular_distribution" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_sdss_angular_distribution" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "random_sdss_angular_distribution" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = cosmobl::random_sdss_angular_distribution(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::shared_ptr< cosmobl::Catalogue >(static_cast< const std::shared_ptr< cosmobl::Catalogue >& >(result))), SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_sdss_angular_distribution(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_random_sdss_angular_distribution__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_random_sdss_angular_distribution__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'random_sdss_angular_distribution'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::random_sdss_angular_distribution(int const,std::string const,std::string const,bool const)\n"
    "    cosmobl::random_sdss_angular_distribution(int const,std::string const,std::string const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Pairs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Pairs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pairs" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_nlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_nlog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_nlog" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = (int)((cosmobl::Pairs const *)arg1)->nlog();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_nlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_nlin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_nlin" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = (int)((cosmobl::Pairs const *)arg1)->nlin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_ncos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_ncos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_ncos" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = (int)((cosmobl::Pairs const *)arg1)->ncos();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_thetaMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_thetaMin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_thetaMin" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = (double)((cosmobl::Pairs const *)arg1)->thetaMin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_thetaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_thetaMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_thetaMax" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = (double)((cosmobl::Pairs const *)arg1)->thetaMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_rMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_rMin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_rMin" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = (double)((cosmobl::Pairs const *)arg1)->rMin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_rMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_rMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_rMax" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = (double)((cosmobl::Pairs const *)arg1)->rMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPlog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_PPlog",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_PPlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Pairs const *)arg1)->PPlog(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPlin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_PPlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_PPlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Pairs const *)arg1)->PPlin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPlog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_PPlog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = ((cosmobl::Pairs const *)arg1)->PPlog();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPlog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs_PPlog__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pairs_PPlog__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_PPlog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::PPlog(int const) const\n"
    "    cosmobl::Pairs::PPlog() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_PPlin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_PPlin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = ((cosmobl::Pairs const *)arg1)->PPlin();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPlin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs_PPlin__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pairs_PPlin__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_PPlin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::PPlin(int const) const\n"
    "    cosmobl::Pairs::PPlin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_PP2d__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_PP2d",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PP2d" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_PP2d" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_PP2d" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((cosmobl::Pairs const *)arg1)->PP2d(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPslog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_PPslog",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPslog" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_PPslog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_PPslog" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((cosmobl::Pairs const *)arg1)->PPslog(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPcoslog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_PPcoslog",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPcoslog" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_PPcoslog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_PPcoslog" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((cosmobl::Pairs const *)arg1)->PPcoslog(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPcoslin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_PPcoslin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPcoslin" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_PPcoslin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_PPcoslin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((cosmobl::Pairs const *)arg1)->PPcoslin(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PP2d__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_PP2d",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PP2d" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = ((cosmobl::Pairs const *)arg1)->PP2d();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >(static_cast< const std::vector< std::vector< double > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PP2d(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs_PP2d__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_PP2d__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_PP2d'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::PP2d(int const,int const) const\n"
    "    cosmobl::Pairs::PP2d() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_PPslog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_PPslog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPslog" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = ((cosmobl::Pairs const *)arg1)->PPslog();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >(static_cast< const std::vector< std::vector< double > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPslog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs_PPslog__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_PPslog__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_PPslog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::PPslog(int const,int const) const\n"
    "    cosmobl::Pairs::PPslog() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_PPcoslog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_PPcoslog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPcoslog" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = ((cosmobl::Pairs const *)arg1)->PPcoslog();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >(static_cast< const std::vector< std::vector< double > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPcoslog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs_PPcoslog__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_PPcoslog__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_PPcoslog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::PPcoslog(int const,int const) const\n"
    "    cosmobl::Pairs::PPcoslog() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_PPcoslin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs_PPcoslin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_PPcoslin" "', argument " "1"" of type '" "cosmobl::Pairs const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  result = ((cosmobl::Pairs const *)arg1)->PPcoslin();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >(static_cast< const std::vector< std::vector< double > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_PPcoslin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs_PPcoslin__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_PPcoslin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_PPcoslin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::PPcoslin(int const,int const) const\n"
    "    cosmobl::Pairs::PPcoslin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_set_nlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_nlog",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_nlog" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_nlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nlog(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_nlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_nlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_nlin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_nlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nlin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_ncos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_ncos",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_ncos" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_ncos" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_ncos(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_rMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_rMin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_rMin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_rMin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_rMin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_rMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_rMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_rMax" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_rMax" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_rMax(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_thetaMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_thetaMin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_thetaMin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_thetaMin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_thetaMin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_thetaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_thetaMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_thetaMax" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_thetaMax" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_thetaMax(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_logbinSize_inv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_logbinSize_inv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_logbinSize_inv" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_logbinSize_inv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_logbinSize_inv(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_linbinSize_inv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_linbinSize_inv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_linbinSize_inv" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_linbinSize_inv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_linbinSize_inv(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_cosbinSize_inv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_set_cosbinSize_inv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_cosbinSize_inv" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_cosbinSize_inv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_cosbinSize_inv(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_PPlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_set_PPlog",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_PPlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_set_PPlog" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->set_PPlog(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_PPlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_set_PPlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_PPlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_set_PPlin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->set_PPlin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_PP2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pairs_set_PP2d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_PP2d" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_PP2d" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_set_PP2d" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pairs_set_PP2d" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_PP2d(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_PPslog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pairs_set_PPslog",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_PPslog" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_PPslog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_set_PPslog" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pairs_set_PPslog" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_PPslog(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_PPcoslog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pairs_set_PPcoslog",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_PPcoslog" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_PPcoslog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_set_PPcoslog" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pairs_set_PPcoslog" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_PPcoslog(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_set_PPcoslin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pairs_set_PPcoslin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_set_PPcoslin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs_set_PPcoslin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_set_PPcoslin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pairs_set_PPcoslin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_PPcoslin(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_1D_log__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_sum_1D_log",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_1D_log" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_1D_log" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_1D_log" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_sum_1D_log" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_1D_log((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_1D_log__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_sum_1D_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_1D_log" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_1D_log" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_1D_log" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_1D_log((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_1D_log(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs_sum_1D_log__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_sum_1D_log__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_sum_1D_log'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::sum_1D_log(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs::sum_1D_log(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_1D_lin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_sum_1D_lin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_1D_lin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_1D_lin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_1D_lin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_sum_1D_lin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_1D_lin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_1D_lin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_sum_1D_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_1D_lin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_1D_lin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_1D_lin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_1D_lin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_1D_lin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs_sum_1D_lin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_sum_1D_lin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_sum_1D_lin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::sum_1D_lin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs::sum_1D_lin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2D_linlin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_sum_2D_linlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_2D_linlin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_2D_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_2D_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_sum_2D_linlin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_2D_linlin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2D_linlin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_sum_2D_linlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_2D_linlin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_2D_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_2D_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_2D_linlin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2D_linlin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs_sum_2D_linlin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_sum_2D_linlin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_sum_2D_linlin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::sum_2D_linlin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs::sum_2D_linlin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2D_loglin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_sum_2D_loglin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_2D_loglin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_2D_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_2D_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_sum_2D_loglin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_2D_loglin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2D_loglin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_sum_2D_loglin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_2D_loglin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_2D_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_2D_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_2D_loglin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2D_loglin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs_sum_2D_loglin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_sum_2D_loglin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_sum_2D_loglin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::sum_2D_loglin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs::sum_2D_loglin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2Drcos_loglin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_sum_2Drcos_loglin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_2Drcos_loglin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_2Drcos_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_2Drcos_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_sum_2Drcos_loglin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_2Drcos_loglin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2Drcos_loglin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_sum_2Drcos_loglin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_2Drcos_loglin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_2Drcos_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_2Drcos_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_2Drcos_loglin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2Drcos_loglin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs_sum_2Drcos_loglin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_sum_2Drcos_loglin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_sum_2Drcos_loglin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::sum_2Drcos_loglin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs::sum_2Drcos_loglin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2Drcos_linlin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_sum_2Drcos_linlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_2Drcos_linlin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_2Drcos_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_2Drcos_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_sum_2Drcos_linlin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_2Drcos_linlin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2Drcos_linlin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_sum_2Drcos_linlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_2Drcos_linlin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_2Drcos_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_2Drcos_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_2Drcos_linlin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_2Drcos_linlin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs_sum_2Drcos_linlin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_sum_2Drcos_linlin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_sum_2Drcos_linlin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::sum_2Drcos_linlin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs::sum_2Drcos_linlin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_all__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Pairs > > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_sum_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'");
    } else {
      std::shared_ptr< cosmobl::Pairs > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Pairs > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_sum_all" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_all(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_all__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Pairs > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_sum_all",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'");
    } else {
      std::shared_ptr< cosmobl::Pairs > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Pairs > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->sum_all(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_all__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_sum_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs_sum_all" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_all((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_all__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs_sum_all",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_all((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_sum_all(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs_sum_all__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs_sum_all__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_sum_all__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs_sum_all__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs_sum_all'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs::sum_all(std::shared_ptr< cosmobl::Pairs > const,double const)\n"
    "    cosmobl::Pairs::sum_all(std::shared_ptr< cosmobl::Pairs > const)\n"
    "    cosmobl::Pairs::sum_all(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs::sum_all(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs_put_1D_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_put_1D_log",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_put_1D_log" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_put_1D_log" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_1D_log" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs_put_1D_log" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_1D_log" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_1D_log(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_put_1D_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_put_1D_lin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_put_1D_lin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_put_1D_lin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_1D_lin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs_put_1D_lin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_1D_lin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_1D_lin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_put_2D_linlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_put_2D_linlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_put_2D_linlin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_put_2D_linlin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_2D_linlin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs_put_2D_linlin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_2D_linlin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_2D_linlin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_put_2D_loglin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_put_2D_loglin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_put_2D_loglin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_put_2D_loglin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_2D_loglin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs_put_2D_loglin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_2D_loglin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_2D_loglin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_put_2Drcos_loglin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_put_2Drcos_loglin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_put_2Drcos_loglin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_put_2Drcos_loglin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_2Drcos_loglin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs_put_2Drcos_loglin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_2Drcos_loglin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_2Drcos_loglin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_put_2Drcos_linlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_put_2Drcos_linlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_put_2Drcos_linlin" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_put_2Drcos_linlin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_2Drcos_linlin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs_put_2Drcos_linlin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_2Drcos_linlin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_2Drcos_linlin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs_put_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *arg1 = (cosmobl::Pairs *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs_put_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs_put_all" "', argument " "1"" of type '" "cosmobl::Pairs *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs_put_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs_put_all" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs_put_all" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_all(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pairs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Pairs")) SWIG_fail;
  result = (cosmobl::Pairs *)new cosmobl::Pairs();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Pairs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Pairs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Pairs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Pairs2D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Pairs2D")) SWIG_fail;
  result = (cosmobl::Pairs2D *)new cosmobl::Pairs2D();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Pairs2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pairs2D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  cosmobl::Pairs2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Pairs2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Pairs2D" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Pairs2D" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pairs2D" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Pairs2D" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Pairs2D" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Pairs2D" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (cosmobl::Pairs2D *)new cosmobl::Pairs2D(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Pairs2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pairs2D(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Pairs2D__SWIG_0(self, args);
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Pairs2D__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Pairs2D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs2D::Pairs2D()\n"
    "    cosmobl::Pairs2D::Pairs2D(int const,int const,double const,double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs2D_nlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs2D_nlog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_nlog" "', argument " "1"" of type '" "cosmobl::Pairs2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  result = (int)((cosmobl::Pairs2D const *)arg1)->nlog();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_nlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs2D_nlin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_nlin" "', argument " "1"" of type '" "cosmobl::Pairs2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  result = (int)((cosmobl::Pairs2D const *)arg1)->nlin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_thetaMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs2D_thetaMin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_thetaMin" "', argument " "1"" of type '" "cosmobl::Pairs2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  result = (double)((cosmobl::Pairs2D const *)arg1)->thetaMin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_thetaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs2D_thetaMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_thetaMax" "', argument " "1"" of type '" "cosmobl::Pairs2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  result = (double)((cosmobl::Pairs2D const *)arg1)->thetaMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_PPlog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_PPlog",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_PPlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Pairs2D const *)arg1)->PPlog(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_PPlin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_PPlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_PPlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Pairs2D const *)arg1)->PPlin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_PPlog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs2D_PPlog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  result = ((cosmobl::Pairs2D const *)arg1)->PPlog();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_PPlog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs2D_PPlog__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pairs2D_PPlog__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs2D_PPlog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs2D::PPlog(int const) const\n"
    "    cosmobl::Pairs2D::PPlog() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs2D_PPlin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs2D_PPlin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  result = ((cosmobl::Pairs2D const *)arg1)->PPlin();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_PPlin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs2D_PPlin__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pairs2D_PPlin__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs2D_PPlin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs2D::PPlin(int const) const\n"
    "    cosmobl::Pairs2D::PPlin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs2D_set_nlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_set_nlog",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_set_nlog" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_set_nlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nlog(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_set_nlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_set_nlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_set_nlin" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_set_nlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nlin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_set_thetaMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_set_thetaMin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_set_thetaMin" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_set_thetaMin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_thetaMin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_set_thetaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_set_thetaMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_set_thetaMax" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_set_thetaMax" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_thetaMax(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_set_logbinSize_inv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_set_logbinSize_inv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_set_logbinSize_inv" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_set_logbinSize_inv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_logbinSize_inv(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_set_linbinSize_inv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_set_linbinSize_inv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_set_linbinSize_inv" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_set_linbinSize_inv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_linbinSize_inv(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_set_PPlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs2D_set_PPlog",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_set_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_set_PPlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs2D_set_PPlog" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->set_PPlog(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_set_PPlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs2D_set_PPlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_set_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs2D_set_PPlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs2D_set_PPlin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->set_PPlin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_sum_all__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Pairs > > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs2D_sum_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs2D_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs2D_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'");
    } else {
      std::shared_ptr< cosmobl::Pairs > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Pairs > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs2D_sum_all" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_all(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_sum_all__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Pairs > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_sum_all",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs2D_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs2D_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'");
    } else {
      std::shared_ptr< cosmobl::Pairs > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Pairs > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->sum_all(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_sum_all__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs2D_sum_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs2D_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs2D_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs2D_sum_all" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_all((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_sum_all__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs2D_sum_all",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs2D_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs2D_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_all((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs2D_sum_all(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs2D_sum_all__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs2D_sum_all__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs2D_sum_all__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs2D_sum_all__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs2D_sum_all'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs2D::sum_all(std::shared_ptr< cosmobl::Pairs > const,double const)\n"
    "    cosmobl::Pairs2D::sum_all(std::shared_ptr< cosmobl::Pairs > const)\n"
    "    cosmobl::Pairs2D::sum_all(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs2D::sum_all(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs2D_put_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs2D_put_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs2D_put_all" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs2D_put_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs2D_put_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs2D_put_all" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs2D_put_all" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_all(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Pairs2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs2D *arg1 = (cosmobl::Pairs2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Pairs2D",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pairs2D" "', argument " "1"" of type '" "cosmobl::Pairs2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs2D * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Pairs2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Pairs2D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Pairs3D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Pairs3D")) SWIG_fail;
  result = (cosmobl::Pairs3D *)new cosmobl::Pairs3D();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Pairs3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pairs3D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  cosmobl::Pairs3D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_Pairs3D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Pairs3D" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Pairs3D" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pairs3D" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Pairs3D" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Pairs3D" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Pairs3D" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Pairs3D" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Pairs3D" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (cosmobl::Pairs3D *)new cosmobl::Pairs3D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Pairs3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pairs3D(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Pairs3D__SWIG_0(self, args);
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Pairs3D__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Pairs3D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::Pairs3D()\n"
    "    cosmobl::Pairs3D::Pairs3D(int const,int const,int const,double const,double const,double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_nlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_nlog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_nlog" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = (int)((cosmobl::Pairs3D const *)arg1)->nlog();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_nlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_nlin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_nlin" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = (int)((cosmobl::Pairs3D const *)arg1)->nlin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_ncos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_ncos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_ncos" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = (int)((cosmobl::Pairs3D const *)arg1)->ncos();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_rMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_rMin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_rMin" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = (double)((cosmobl::Pairs3D const *)arg1)->rMin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_rMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_rMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_rMax" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = (double)((cosmobl::Pairs3D const *)arg1)->rMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPlog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_PPlog",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_PPlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Pairs3D const *)arg1)->PPlog(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPlin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_PPlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_PPlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Pairs3D const *)arg1)->PPlin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PP2d__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_PP2d",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PP2d" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_PP2d" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_PP2d" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((cosmobl::Pairs3D const *)arg1)->PP2d(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPslog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_PPslog",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPslog" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_PPslog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_PPslog" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((cosmobl::Pairs3D const *)arg1)->PPslog(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPcoslog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_PPcoslog",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPcoslog" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_PPcoslog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_PPcoslog" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((cosmobl::Pairs3D const *)arg1)->PPcoslog(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPcoslin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_PPcoslin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPcoslin" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_PPcoslin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_PPcoslin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((cosmobl::Pairs3D const *)arg1)->PPcoslin(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPlog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_PPlog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = ((cosmobl::Pairs3D const *)arg1)->PPlog();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPlog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs3D_PPlog__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pairs3D_PPlog__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_PPlog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::PPlog(int const) const\n"
    "    cosmobl::Pairs3D::PPlog() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPlin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_PPlin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = ((cosmobl::Pairs3D const *)arg1)->PPlin();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPlin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs3D_PPlin__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pairs3D_PPlin__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_PPlin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::PPlin(int const) const\n"
    "    cosmobl::Pairs3D::PPlin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PP2d__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_PP2d",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PP2d" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = ((cosmobl::Pairs3D const *)arg1)->PP2d();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >(static_cast< const std::vector< std::vector< double > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PP2d(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs3D_PP2d__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_PP2d__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_PP2d'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::PP2d(int const,int const) const\n"
    "    cosmobl::Pairs3D::PP2d() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPslog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_PPslog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPslog" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = ((cosmobl::Pairs3D const *)arg1)->PPslog();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >(static_cast< const std::vector< std::vector< double > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPslog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs3D_PPslog__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_PPslog__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_PPslog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::PPslog(int const,int const) const\n"
    "    cosmobl::Pairs3D::PPslog() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPcoslog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_PPcoslog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPcoslog" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = ((cosmobl::Pairs3D const *)arg1)->PPcoslog();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >(static_cast< const std::vector< std::vector< double > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPcoslog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs3D_PPcoslog__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_PPcoslog__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_PPcoslog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::PPcoslog(int const,int const) const\n"
    "    cosmobl::Pairs3D::PPcoslog() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPcoslin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pairs3D_PPcoslin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_PPcoslin" "', argument " "1"" of type '" "cosmobl::Pairs3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  result = ((cosmobl::Pairs3D const *)arg1)->PPcoslin();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >(static_cast< const std::vector< std::vector< double > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_PPcoslin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pairs3D_PPcoslin__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_PPcoslin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_PPcoslin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::PPcoslin(int const,int const) const\n"
    "    cosmobl::Pairs3D::PPcoslin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_nlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_set_nlog",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_nlog" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_nlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nlog(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_nlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_set_nlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_nlin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_nlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nlin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_ncos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_set_ncos",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_ncos" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_ncos" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_ncos(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_rMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_set_rMin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_rMin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_rMin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_rMin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_rMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_set_rMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_rMax" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_rMax" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_rMax(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_logbinSize_inv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_set_logbinSize_inv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_logbinSize_inv" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_logbinSize_inv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_logbinSize_inv(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_linbinSize_inv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_set_linbinSize_inv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_linbinSize_inv" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_linbinSize_inv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_linbinSize_inv(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_cosbinSize_inv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_set_cosbinSize_inv",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_cosbinSize_inv" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_cosbinSize_inv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->set_cosbinSize_inv(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_PPlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_set_PPlog",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_PPlog" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_PPlog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_set_PPlog" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->set_PPlog(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_PPlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_set_PPlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_PPlin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_PPlin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_set_PPlin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->set_PPlin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_PP2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pairs3D_set_PP2d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_PP2d" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_PP2d" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_set_PP2d" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pairs3D_set_PP2d" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_PP2d(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_PPslog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pairs3D_set_PPslog",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_PPslog" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_PPslog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_set_PPslog" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pairs3D_set_PPslog" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_PPslog(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_PPcoslog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pairs3D_set_PPcoslog",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_PPcoslog" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_PPcoslog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_set_PPcoslog" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pairs3D_set_PPcoslog" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_PPcoslog(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_set_PPcoslin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pairs3D_set_PPcoslin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_set_PPcoslin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pairs3D_set_PPcoslin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_set_PPcoslin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pairs3D_set_PPcoslin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set_PPcoslin(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_1D_log__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_sum_1D_log",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_1D_log" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_1D_log" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_1D_log" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_sum_1D_log" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_1D_log((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_1D_log__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_sum_1D_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_1D_log" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_1D_log" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_1D_log" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_1D_log((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_1D_log(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs3D_sum_1D_log__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_sum_1D_log__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_sum_1D_log'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::sum_1D_log(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs3D::sum_1D_log(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_1D_lin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_sum_1D_lin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_1D_lin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_1D_lin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_1D_lin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_sum_1D_lin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_1D_lin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_1D_lin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_sum_1D_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_1D_lin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_1D_lin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_1D_lin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_1D_lin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_1D_lin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs3D_sum_1D_lin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_sum_1D_lin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_sum_1D_lin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::sum_1D_lin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs3D::sum_1D_lin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2D_linlin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_sum_2D_linlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_2D_linlin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_2D_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_2D_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_sum_2D_linlin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_2D_linlin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2D_linlin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_sum_2D_linlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_2D_linlin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_2D_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_2D_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_2D_linlin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2D_linlin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs3D_sum_2D_linlin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_sum_2D_linlin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_sum_2D_linlin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::sum_2D_linlin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs3D::sum_2D_linlin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2D_loglin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_sum_2D_loglin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_2D_loglin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_2D_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_2D_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_sum_2D_loglin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_2D_loglin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2D_loglin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_sum_2D_loglin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_2D_loglin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_2D_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_2D_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_2D_loglin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2D_loglin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs3D_sum_2D_loglin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_sum_2D_loglin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_sum_2D_loglin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::sum_2D_loglin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs3D::sum_2D_loglin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2Drcos_loglin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_sum_2Drcos_loglin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_2Drcos_loglin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_2Drcos_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_2Drcos_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_sum_2Drcos_loglin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_2Drcos_loglin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2Drcos_loglin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_sum_2Drcos_loglin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_2Drcos_loglin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_2Drcos_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_2Drcos_loglin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_2Drcos_loglin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2Drcos_loglin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs3D_sum_2Drcos_loglin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_sum_2Drcos_loglin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_sum_2Drcos_loglin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::sum_2Drcos_loglin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs3D::sum_2Drcos_loglin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2Drcos_linlin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_sum_2Drcos_linlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_2Drcos_linlin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_2Drcos_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_2Drcos_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_sum_2Drcos_linlin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_2Drcos_linlin((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2Drcos_linlin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_sum_2Drcos_linlin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_2Drcos_linlin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_2Drcos_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_2Drcos_linlin" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_2Drcos_linlin((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_2Drcos_linlin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs3D_sum_2Drcos_linlin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_sum_2Drcos_linlin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_sum_2Drcos_linlin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::sum_2Drcos_linlin(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs3D::sum_2Drcos_linlin(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_all__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Pairs > > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_sum_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'");
    } else {
      std::shared_ptr< cosmobl::Pairs > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Pairs > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_sum_all" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_all(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_all__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Pairs > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_sum_all",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Pairs > const""'");
    } else {
      std::shared_ptr< cosmobl::Pairs > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Pairs > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->sum_all(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_all__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_sum_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pairs3D_sum_all" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum_all((cosmobl::Pairs const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_all__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  cosmobl::Pairs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pairs3D_sum_all",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_sum_all" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Pairs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_sum_all" "', argument " "2"" of type '" "cosmobl::Pairs const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Pairs * >(argp2);
  (arg1)->sum_all((cosmobl::Pairs const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_sum_all(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs3D_sum_all__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pairs3D_sum_all__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Pairs, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_sum_all__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Pairs3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Pairs_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pairs3D_sum_all__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pairs3D_sum_all'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Pairs3D::sum_all(std::shared_ptr< cosmobl::Pairs > const,double const)\n"
    "    cosmobl::Pairs3D::sum_all(std::shared_ptr< cosmobl::Pairs > const)\n"
    "    cosmobl::Pairs3D::sum_all(cosmobl::Pairs const &,double const)\n"
    "    cosmobl::Pairs3D::sum_all(cosmobl::Pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pairs3D_put_1D_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_put_1D_log",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_put_1D_log" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_put_1D_log" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_1D_log" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs3D_put_1D_log" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_1D_log" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_1D_log(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_put_1D_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_put_1D_lin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_put_1D_lin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_put_1D_lin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_1D_lin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs3D_put_1D_lin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_1D_lin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_1D_lin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_put_2D_linlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_put_2D_linlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_put_2D_linlin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_put_2D_linlin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_2D_linlin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs3D_put_2D_linlin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_2D_linlin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_2D_linlin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_put_2D_loglin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_put_2D_loglin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_put_2D_loglin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_put_2D_loglin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_2D_loglin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs3D_put_2D_loglin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_2D_loglin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_2D_loglin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_put_2Drcos_loglin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_put_2Drcos_loglin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_put_2Drcos_loglin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_put_2Drcos_loglin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_2Drcos_loglin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs3D_put_2Drcos_loglin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_2Drcos_loglin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_2Drcos_loglin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_put_2Drcos_linlin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_put_2Drcos_linlin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_put_2Drcos_linlin" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_put_2Drcos_linlin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_2Drcos_linlin" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs3D_put_2Drcos_linlin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_2Drcos_linlin" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_2Drcos_linlin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pairs3D_put_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pairs3D_put_all",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pairs3D_put_all" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pairs3D_put_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_all" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pairs3D_put_all" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pairs3D_put_all" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->put_all(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Pairs3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Pairs3D *arg1 = (cosmobl::Pairs3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Pairs3D",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Pairs3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pairs3D" "', argument " "1"" of type '" "cosmobl::Pairs3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Pairs3D * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Pairs3D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Pairs3D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TwoPointCorrelation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TwoPointCorrelation")) SWIG_fail;
  result = (cosmobl::TwoPointCorrelation *)new cosmobl::TwoPointCorrelation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__TwoPointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TwoPointCorrelation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TwoPointCorrelation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TwoPointCorrelation" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TwoPointCorrelation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::TwoPointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_TwoPointCorrelation",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TwoPointCorrelation" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TwoPointCorrelation" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TwoPointCorrelation" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TwoPointCorrelation" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TwoPointCorrelation" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (cosmobl::TwoPointCorrelation *)new cosmobl::TwoPointCorrelation(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__TwoPointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TwoPointCorrelation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::TwoPointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TwoPointCorrelation",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TwoPointCorrelation" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TwoPointCorrelation" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TwoPointCorrelation" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TwoPointCorrelation" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (cosmobl::TwoPointCorrelation *)new cosmobl::TwoPointCorrelation(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__TwoPointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TwoPointCorrelation__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue arg1 ;
  cosmobl::Catalogue arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  cosmobl::TwoPointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_TwoPointCorrelation",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cosmobl__Catalogue,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TwoPointCorrelation" "', argument " "1"" of type '" "cosmobl::Catalogue""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TwoPointCorrelation" "', argument " "1"" of type '" "cosmobl::Catalogue""'");
    } else {
      cosmobl::Catalogue * temp = reinterpret_cast< cosmobl::Catalogue * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Catalogue,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TwoPointCorrelation" "', argument " "2"" of type '" "cosmobl::Catalogue""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TwoPointCorrelation" "', argument " "2"" of type '" "cosmobl::Catalogue""'");
    } else {
      cosmobl::Catalogue * temp = reinterpret_cast< cosmobl::Catalogue * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TwoPointCorrelation" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (cosmobl::TwoPointCorrelation *)new cosmobl::TwoPointCorrelation(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__TwoPointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TwoPointCorrelation__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Catalogue arg1 ;
  cosmobl::Catalogue arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::TwoPointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TwoPointCorrelation",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cosmobl__Catalogue,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TwoPointCorrelation" "', argument " "1"" of type '" "cosmobl::Catalogue""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TwoPointCorrelation" "', argument " "1"" of type '" "cosmobl::Catalogue""'");
    } else {
      cosmobl::Catalogue * temp = reinterpret_cast< cosmobl::Catalogue * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Catalogue,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TwoPointCorrelation" "', argument " "2"" of type '" "cosmobl::Catalogue""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TwoPointCorrelation" "', argument " "2"" of type '" "cosmobl::Catalogue""'");
    } else {
      cosmobl::Catalogue * temp = reinterpret_cast< cosmobl::Catalogue * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (cosmobl::TwoPointCorrelation *)new cosmobl::TwoPointCorrelation(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__TwoPointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TwoPointCorrelation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_TwoPointCorrelation__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TwoPointCorrelation__SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Catalogue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TwoPointCorrelation__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cosmobl__Catalogue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cosmobl__Catalogue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TwoPointCorrelation__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TwoPointCorrelation__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TwoPointCorrelation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::TwoPointCorrelation()\n"
    "    cosmobl::TwoPointCorrelation::TwoPointCorrelation(std::shared_ptr< cosmobl::Catalogue >,std::shared_ptr< cosmobl::Catalogue >,bool)\n"
    "    cosmobl::TwoPointCorrelation::TwoPointCorrelation(std::shared_ptr< cosmobl::Catalogue >,std::shared_ptr< cosmobl::Catalogue >)\n"
    "    cosmobl::TwoPointCorrelation::TwoPointCorrelation(cosmobl::Catalogue,cosmobl::Catalogue,bool)\n"
    "    cosmobl::TwoPointCorrelation::TwoPointCorrelation(cosmobl::Catalogue,cosmobl::Catalogue)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_setParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_setParameters",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_setParameters" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_setParameters" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_setParameters" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_setParameters" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_setParameters" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_setParameters" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TwoPointCorrelation_setParameters" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->setParameters(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_setParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TwoPointCorrelation_setParameters",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_setParameters" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_setParameters" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_setParameters" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_setParameters" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_setParameters" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_setParameters" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  (arg1)->setParameters(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_setParameters(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TwoPointCorrelation_setParameters__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TwoPointCorrelation_setParameters__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_setParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::setParameters(double,double,double,double,double,bool)\n"
    "    cosmobl::TwoPointCorrelation::setParameters(double,double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_allocate_vectors_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  bool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_allocate_vectors_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_allocate_vectors_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_allocate_vectors_xi" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_allocate_vectors_xi" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  (arg1)->allocate_vectors_xi(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_allocate_vectors_ACF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  bool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_allocate_vectors_ACF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_allocate_vectors_ACF" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_allocate_vectors_ACF" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_allocate_vectors_ACF" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  (arg1)->allocate_vectors_ACF(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_erase_multipoles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_erase_multipoles",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_erase_multipoles" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  (arg1)->erase_multipoles();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  SwigValueWrapper< std::vector< std::string > > arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  bool arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::vector< std::string >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::vector< std::string >""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  SwigValueWrapper< std::vector< std::string > > arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::vector< std::string >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::vector< std::string >""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->measure_xi(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_measure_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::string > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_measure_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string >""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->measure_xi(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::string > > arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string >""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::string > > arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string >""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  SwigValueWrapper< std::vector< std::string > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::vector< std::string >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::vector< std::string >""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->measure_xi(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_xi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_write_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_write_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_write_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_write_xi" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->write_xi(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_xi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_write_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_write_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_write_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->write_xi(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_xi__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg2 ;
  std::string arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_write_xi",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_write_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_write_xi" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_write_xi" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_write_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_write_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->write_xi(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_xi__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_write_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_write_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_write_xi" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_write_xi" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_write_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->write_xi(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_xi(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TwoPointCorrelation_write_xi__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_write_xi__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TwoPointCorrelation_write_xi__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TwoPointCorrelation_write_xi__SWIG_2(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_write_xi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::write_xi(std::string,int)\n"
    "    cosmobl::TwoPointCorrelation::write_xi(std::string)\n"
    "    cosmobl::TwoPointCorrelation::write_xi(std::vector< std::vector< double > >,std::string,int)\n"
    "    cosmobl::TwoPointCorrelation::write_xi(std::vector< std::vector< double > >,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_count_pairs_regions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  cosmobl::ChainMesh_Catalogue *arg3 = 0 ;
  SwigValueWrapper< std::vector< std::shared_ptr< cosmobl::Pairs > > > arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TwoPointCorrelation_count_pairs_regions",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__ChainMesh_Catalogue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "3"" of type '" "cosmobl::ChainMesh_Catalogue &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "3"" of type '" "cosmobl::ChainMesh_Catalogue &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::ChainMesh_Catalogue * >(argp3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "4"" of type '" "std::vector< std::shared_ptr< cosmobl::Pairs > >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "4"" of type '" "std::vector< std::shared_ptr< cosmobl::Pairs > >""'");
    } else {
      std::vector< std::shared_ptr< cosmobl::Pairs > > * temp = reinterpret_cast< std::vector< std::shared_ptr< cosmobl::Pairs > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->count_pairs_regions(arg2,*arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_count_pairs_regions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  cosmobl::ChainMesh_Catalogue *arg3 = 0 ;
  SwigValueWrapper< std::vector< std::shared_ptr< cosmobl::Pairs > > > arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_count_pairs_regions",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__ChainMesh_Catalogue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "3"" of type '" "cosmobl::ChainMesh_Catalogue &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "3"" of type '" "cosmobl::ChainMesh_Catalogue &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::ChainMesh_Catalogue * >(argp3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "4"" of type '" "std::vector< std::shared_ptr< cosmobl::Pairs > >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "4"" of type '" "std::vector< std::shared_ptr< cosmobl::Pairs > >""'");
    } else {
      std::vector< std::shared_ptr< cosmobl::Pairs > > * temp = reinterpret_cast< std::vector< std::shared_ptr< cosmobl::Pairs > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_count_pairs_regions" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->count_pairs_regions(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_count_pairs_regions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TwoPointCorrelation_count_pairs_regions__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_cosmobl__ChainMesh_Catalogue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TwoPointCorrelation_count_pairs_regions__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_count_pairs_regions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::count_pairs_regions(std::shared_ptr< cosmobl::Catalogue >,cosmobl::ChainMesh_Catalogue &,std::vector< std::shared_ptr< cosmobl::Pairs > >,bool,bool)\n"
    "    cosmobl::TwoPointCorrelation::count_pairs_regions(std::shared_ptr< cosmobl::Catalogue >,cosmobl::ChainMesh_Catalogue &,std::vector< std::shared_ptr< cosmobl::Pairs > >,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  int arg6 ;
  std::vector< std::string > *arg7 = 0 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  bool arg11 ;
  std::string arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< std::string > * >(argp7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "12"" of type '" "std::string""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,(std::vector< std::string > const &)*arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  int arg6 ;
  std::vector< std::string > *arg7 = 0 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  bool arg11 ;
  std::string arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< std::string > * >(argp7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj11, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "12"" of type '" "std::string""'"); 
    }
    arg12 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,(std::vector< std::string > const &)*arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  int arg6 ;
  std::vector< std::string > *arg7 = 0 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< std::string > * >(argp7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,(std::vector< std::string > const &)*arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  int arg6 ;
  std::vector< std::string > *arg7 = 0 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< std::string > * >(argp7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,(std::vector< std::string > const &)*arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  int arg6 ;
  std::vector< std::string > *arg7 = 0 ;
  int arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< std::string > * >(argp7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,(std::vector< std::string > const &)*arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  int arg6 ;
  std::vector< std::string > *arg7 = 0 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< std::string > * >(argp7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,(std::vector< std::string > const &)*arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  int arg6 ;
  std::vector< std::string > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< std::string > * >(argp7);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,(std::vector< std::string > const &)*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->measure_xi(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_22(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi((std::vector< std::string > const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_23(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi((std::vector< std::string > const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_24(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  std::string arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_25(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_26(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->measure_xi(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_27(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string arg3 ;
  int arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_xi((std::vector< std::string > const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi__SWIG_28(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_measure_xi",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_xi" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_xi" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->measure_xi((std::vector< std::string > const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_xi(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[14] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 13) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TwoPointCorrelation_measure_xi__SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TwoPointCorrelation_measure_xi__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_measure_xi__SWIG_23(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_measure_xi__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TwoPointCorrelation_measure_xi__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_measure_xi__SWIG_21(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TwoPointCorrelation_measure_xi__SWIG_28(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TwoPointCorrelation_measure_xi__SWIG_22(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TwoPointCorrelation_measure_xi__SWIG_20(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TwoPointCorrelation_measure_xi__SWIG_19(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TwoPointCorrelation_measure_xi__SWIG_27(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TwoPointCorrelation_measure_xi__SWIG_16(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TwoPointCorrelation_measure_xi__SWIG_26(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TwoPointCorrelation_measure_xi__SWIG_18(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TwoPointCorrelation_measure_xi__SWIG_6(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TwoPointCorrelation_measure_xi__SWIG_15(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_TwoPointCorrelation_measure_xi__SWIG_25(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TwoPointCorrelation_measure_xi__SWIG_17(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TwoPointCorrelation_measure_xi__SWIG_5(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TwoPointCorrelation_measure_xi__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_TwoPointCorrelation_measure_xi__SWIG_14(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TwoPointCorrelation_measure_xi__SWIG_24(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TwoPointCorrelation_measure_xi__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TwoPointCorrelation_measure_xi__SWIG_13(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TwoPointCorrelation_measure_xi__SWIG_12(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_TwoPointCorrelation_measure_xi__SWIG_11(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_TwoPointCorrelation_measure_xi__SWIG_10(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_TwoPointCorrelation_measure_xi__SWIG_9(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_TwoPointCorrelation_measure_xi__SWIG_8(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_measure_xi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::vector< std::string >,int,int,int,bool,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::vector< std::string >,int,int,int,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::vector< std::string >)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::vector< std::string >,int,int,int,bool,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::vector< std::string >,int,int,int,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::vector< std::string >)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool,int,std::vector< std::string > const &,int,int,int,bool,std::string,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool,int,std::vector< std::string > const &,int,int,int,bool,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool,int,std::vector< std::string > const &,int,int,int,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool,int,std::vector< std::string > const &,int,int,int)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool,int,std::vector< std::string > const &,int,int)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool,int,std::vector< std::string > const &,int)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool,int,std::vector< std::string > const &)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool,int)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,std::string,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::vector< std::string > const &,std::string,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::vector< std::string > const &,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,int,std::string,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,int,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::string,std::string,std::string,int)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::vector< std::string > const &,std::string,int,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_xi(std::vector< std::string > const &,std::string,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_get_covariance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  bool *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_get_covariance",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_get_covariance" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_get_covariance" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_get_covariance" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_get_covariance" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_get_covariance" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_get_covariance" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->get_covariance(*arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_get_covariance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  bool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_get_covariance",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_get_covariance" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_get_covariance" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_get_covariance" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_get_covariance" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_get_covariance" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  (arg1)->get_covariance(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_get_covariance(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_bool, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_get_covariance__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_bool, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TwoPointCorrelation_get_covariance__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_get_covariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::get_covariance(std::string &,bool &,std::string)\n"
    "    cosmobl::TwoPointCorrelation::get_covariance(std::string &,bool &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_gg_pairs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg4 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg5 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg6 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_set_gg_pairs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "4"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "4"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "5"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "5"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "6"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "6"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "7"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gg_pairs" "', argument " "7"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  (arg1)->set_gg_pairs(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_rr_pairs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg4 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg5 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg6 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_set_rr_pairs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "4"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "4"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "5"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "5"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "6"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "6"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "7"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_rr_pairs" "', argument " "7"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  (arg1)->set_rr_pairs(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_gr_pairs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg4 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg5 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg6 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_set_gr_pairs",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "4"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "4"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "5"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "5"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "6"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "6"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "7"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_gr_pairs" "', argument " "7"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  (arg1)->set_gr_pairs(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_pairs_subSamples(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::shared_ptr< cosmobl::Pairs > > > arg2 ;
  int arg3 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_write_pairs_subSamples",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_write_pairs_subSamples" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_write_pairs_subSamples" "', argument " "2"" of type '" "std::vector< std::shared_ptr< cosmobl::Pairs > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_write_pairs_subSamples" "', argument " "2"" of type '" "std::vector< std::shared_ptr< cosmobl::Pairs > >""'");
    } else {
      std::vector< std::shared_ptr< cosmobl::Pairs > > * temp = reinterpret_cast< std::vector< std::shared_ptr< cosmobl::Pairs > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_write_pairs_subSamples" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_write_pairs_subSamples" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_write_pairs_subSamples" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_write_pairs_subSamples" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_write_pairs_subSamples" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  (arg1)->write_pairs_subSamples(arg2,arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_read_pairs_subSamples(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::shared_ptr< cosmobl::Pairs > > > arg2 ;
  int arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  std::string *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_read_pairs_subSamples",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_read_pairs_subSamples" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_read_pairs_subSamples" "', argument " "2"" of type '" "std::vector< std::shared_ptr< cosmobl::Pairs > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_read_pairs_subSamples" "', argument " "2"" of type '" "std::vector< std::shared_ptr< cosmobl::Pairs > >""'");
    } else {
      std::vector< std::shared_ptr< cosmobl::Pairs > > * temp = reinterpret_cast< std::vector< std::shared_ptr< cosmobl::Pairs > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_read_pairs_subSamples" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_read_pairs_subSamples" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_read_pairs_subSamples" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_read_pairs_subSamples" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_read_pairs_subSamples" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  (arg1)->read_pairs_subSamples(arg2,arg3,(std::vector< std::string > const &)*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_xi_Mocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_write_xi_Mocks",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_write_xi_Mocks" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_write_xi_Mocks" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->write_xi_Mocks(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_projected_xi_Mocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_projected_xi_Mocks",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_projected_xi_Mocks" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_measure_projected_xi_Mocks" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_projected_xi_Mocks" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_projected_xi_Mocks(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  bool arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::string > * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  (arg1)->measure_wtheta(arg2,(std::vector< std::string > const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::string > * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->measure_wtheta(arg2,(std::vector< std::string > const &)*arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::string > * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->measure_wtheta(arg2,(std::vector< std::string > const &)*arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::string > * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->measure_wtheta(arg2,(std::vector< std::string > const &)*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::string > * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->measure_wtheta(arg2,(std::vector< std::string > const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::string > * >(argp3);
  (arg1)->measure_wtheta(arg2,(std::vector< std::string > const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_wtheta(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_measure_wtheta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  (arg1)->measure_wtheta();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->measure_wtheta(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_wtheta",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_measure_wtheta" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->measure_wtheta((std::vector< std::string > const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_wtheta(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_7(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_6(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_9(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_8(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TwoPointCorrelation_measure_wtheta__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_measure_wtheta'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::string,std::vector< std::string > const &,int,int,int,bool,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::string,std::vector< std::string > const &,int,int,int,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::string,std::vector< std::string > const &,int,int,int)\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::string,std::vector< std::string > const &,int,int)\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::string,std::vector< std::string > const &,int)\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::string,std::vector< std::string > const &)\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta()\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::string,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_wtheta(std::vector< std::string > const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_wtheta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_write_wtheta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_write_wtheta" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_write_wtheta" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_write_wtheta" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  (arg1)->write_wtheta(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_Error",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_Error" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_Error" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_Error" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_Error" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_Error" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  result = (double)(arg1)->Error(*arg2,*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_Error",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_Error" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_Error" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_Error" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_Error" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_Error" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_Error" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_Error" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (double)(arg1)->Error(*arg2,*arg3,*arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Error(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_Error__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TwoPointCorrelation_Error__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_Error'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::Error(double &,double &)\n"
    "    cosmobl::TwoPointCorrelation::Error(double &,double &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_covariance_1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg4 = 0 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_measure_covariance_1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_covariance_1D(*arg2,*arg3,*arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_covariance_1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_measure_covariance_1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_covariance_1D" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp4);
  (arg1)->measure_covariance_1D(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_covariance_1D(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TwoPointCorrelation_measure_covariance_1D__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TwoPointCorrelation_measure_covariance_1D__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_measure_covariance_1D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::measure_covariance_1D(std::vector< std::string > &,std::vector< double > &,std::vector< std::vector< double,std::allocator< double > > > &,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_covariance_1D(std::vector< std::string > &,std::vector< double > &,std::vector< std::vector< double,std::allocator< double > > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_projected_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_measure_projected_xi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_projected_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_projected_xi" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_projected_xi" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_projected_xi" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_projected_xi" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  (arg1)->measure_projected_xi(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_multipoles_xirmu__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_measure_multipoles_xirmu",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_multipoles_xirmu" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_measure_multipoles_xirmu" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->measure_multipoles_xirmu(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_multipoles_xirmu__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_measure_multipoles_xirmu",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_multipoles_xirmu" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  (arg1)->measure_multipoles_xirmu();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_multipoles_xirmu(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TwoPointCorrelation_measure_multipoles_xirmu__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TwoPointCorrelation_measure_multipoles_xirmu__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_measure_multipoles_xirmu'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::measure_multipoles_xirmu(double)\n"
    "    cosmobl::TwoPointCorrelation::measure_multipoles_xirmu()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_multipoles_xirppi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_measure_multipoles_xirppi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_multipoles_xirppi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_measure_multipoles_xirppi" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->measure_multipoles_xirppi(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_multipoles_xirppi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_measure_multipoles_xirppi",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_multipoles_xirppi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  (arg1)->measure_multipoles_xirppi();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_multipoles_xirppi(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TwoPointCorrelation_measure_multipoles_xirppi__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TwoPointCorrelation_measure_multipoles_xirppi__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_measure_multipoles_xirppi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::measure_multipoles_xirppi(int)\n"
    "    cosmobl::TwoPointCorrelation::measure_multipoles_xirppi()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_effective_multipoles_xirppi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_measure_effective_multipoles_xirppi",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_effective_multipoles_xirppi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  (arg1)->measure_effective_multipoles_xirppi();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_write_multipoles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_write_multipoles",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_write_multipoles" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_write_multipoles" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_write_multipoles" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_write_multipoles" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_write_multipoles" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  (arg1)->write_multipoles(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_read_multipoles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_read_multipoles",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_read_multipoles" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_read_multipoles" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_read_multipoles" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_read_multipoles" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_read_multipoles" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  (arg1)->read_multipoles(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_normalized_quadrupole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_measure_normalized_quadrupole",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_normalized_quadrupole" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_measure_normalized_quadrupole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->measure_normalized_quadrupole(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_normalized_quadrupole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_measure_normalized_quadrupole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_normalized_quadrupole" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  (arg1)->measure_normalized_quadrupole();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_normalized_quadrupole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TwoPointCorrelation_measure_normalized_quadrupole__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TwoPointCorrelation_measure_normalized_quadrupole__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_measure_normalized_quadrupole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::measure_normalized_quadrupole(double)\n"
    "    cosmobl::TwoPointCorrelation::measure_normalized_quadrupole()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sigmaR_obj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_sigmaR_obj",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sigmaR_obj" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_sigmaR_obj" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_sigmaR_obj" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->sigmaR_obj(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_bias__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  std::string arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_measure_bias",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->measure_bias(*arg2,*arg3,*arg4,*arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_bias__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TwoPointCorrelation_measure_bias",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_bias(*arg2,*arg3,*arg4,*arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_bias__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_measure_bias",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_measure_bias" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_measure_bias" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  (arg1)->measure_bias(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_measure_bias(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TwoPointCorrelation_measure_bias__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_TwoPointCorrelation_measure_bias__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TwoPointCorrelation_measure_bias__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_measure_bias'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::measure_bias(cosmobl::Cosmology &,double &,std::string &,std::string &,std::string,bool)\n"
    "    cosmobl::TwoPointCorrelation::measure_bias(cosmobl::Cosmology &,double &,std::string &,std::string &,std::string)\n"
    "    cosmobl::TwoPointCorrelation::measure_bias(cosmobl::Cosmology &,double &,std::string &,std::string &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_mean_bias__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_mean_bias",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->mean_bias(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_mean_bias__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_mean_bias",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->mean_bias(*arg2,*arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_mean_bias__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_mean_bias",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  result = (double)(arg1)->mean_bias(*arg2,*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_mean_bias(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_mean_bias__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TwoPointCorrelation_mean_bias__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TwoPointCorrelation_mean_bias__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_mean_bias'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::mean_bias(double &,double &,bool,bool)\n"
    "    cosmobl::TwoPointCorrelation::mean_bias(double &,double &,bool)\n"
    "    cosmobl::TwoPointCorrelation::mean_bias(double &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_mean_bias__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_error_mean_bias",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->error_mean_bias(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_mean_bias__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_error_mean_bias",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->error_mean_bias(*arg2,*arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_mean_bias__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_error_mean_bias",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_error_mean_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  result = (double)(arg1)->error_mean_bias(*arg2,*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_mean_bias(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_error_mean_bias__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TwoPointCorrelation_error_mean_bias__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TwoPointCorrelation_error_mean_bias__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_error_mean_bias'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::error_mean_bias(double &,double &,bool,bool)\n"
    "    cosmobl::TwoPointCorrelation::error_mean_bias(double &,double &,bool)\n"
    "    cosmobl::TwoPointCorrelation::error_mean_bias(double &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_fit_bias__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_fit_bias",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_fit_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_fit_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->fit_bias(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_fit_bias__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_fit_bias",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_fit_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_fit_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->fit_bias(*arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_fit_bias__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_fit_bias",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_fit_bias" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_fit_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_fit_bias" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->fit_bias(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_fit_bias(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TwoPointCorrelation_fit_bias__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TwoPointCorrelation_fit_bias__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TwoPointCorrelation_fit_bias__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_fit_bias'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::fit_bias(double &,double &,bool,bool)\n"
    "    cosmobl::TwoPointCorrelation::fit_bias(double &,double &,bool)\n"
    "    cosmobl::TwoPointCorrelation::fit_bias(double &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_read_bias__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_read_bias",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_read_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_read_bias" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_read_bias" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_read_bias" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->read_bias(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_read_bias__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_read_bias",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_read_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_read_bias" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_read_bias" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  (arg1)->read_bias(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_read_bias(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TwoPointCorrelation_read_bias__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TwoPointCorrelation_read_bias__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TwoPointCorrelation_read_bias'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::TwoPointCorrelation::read_bias(std::string &,bool)\n"
    "    cosmobl::TwoPointCorrelation::read_bias(std::string &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_compute_real_space_xi_deprojected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_compute_real_space_xi_deprojected",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_compute_real_space_xi_deprojected" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_compute_real_space_xi_deprojected" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_compute_real_space_xi_deprojected" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_compute_real_space_xi_deprojected" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_compute_real_space_xi_deprojected" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  (arg1)->compute_real_space_xi_deprojected(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_derive_real_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TwoPointCorrelation_derive_real_xi",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_derive_real_xi" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  (arg1)->derive_real_xi(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_N_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_N_R",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_N_R" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->N_R();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_nlinbins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_nlinbins",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_nlinbins" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->nlinbins();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_nlogbins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_nlogbins",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_nlogbins" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->nlogbins();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_ncosbins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_ncosbins",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_ncosbins" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->ncosbins();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_linbinsz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_linbinsz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_linbinsz" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->linbinsz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_logbinsz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_logbinsz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_logbinsz" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->logbinsz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_cosbinsz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_cosbinsz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_cosbinsz" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->cosbinsz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_shift_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_shift_lin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_shift_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->shift_lin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_shift_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_shift_log",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_shift_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->shift_log();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_shift_cos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_shift_cos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_shift_cos" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->shift_cos();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rad_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rad_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rad_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rad_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rad_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rad_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rad_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rad_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rad_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rad_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi_2d_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_xi_2d_lin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi_2d_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi_2d_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_xi_2d_lin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->xi_2d_lin(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi_2d_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TwoPointCorrelation_error_xi_2d_lin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi_2d_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi_2d_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TwoPointCorrelation_error_xi_2d_lin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->error_xi_2d_lin(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rad_real_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rad_real_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rad_real_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rad_real_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rad_real_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi_real_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi_real_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi_real_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi_real_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi_real_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi_real_lin_extr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi_real_lin_extr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi_real_lin_extr" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi_real_lin_extr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi_real_lin_extr(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi_real_lin_interp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi_real_lin_interp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi_real_lin_interp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi_real_lin_interp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi_real_lin_interp(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi_real_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi_real_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi_real_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi_real_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi_real_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rad_real_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rad_real_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rad_real_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rad_real_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rad_real_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi_real_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi_real_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi_real_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi_real_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi_real_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rp_proj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rp_proj",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rp_proj" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rp_proj" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rp_proj(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi_proj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi_proj",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi_proj" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi_proj" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi_proj(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi_proj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi_proj",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi_proj" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi_proj" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi_proj(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi0_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi0_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi0_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi0_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi0_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi2_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi2_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi2_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi2_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi2_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi4_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi4_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi4_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi4_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi4_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi0_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi0_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi0_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi0_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi0_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi2_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi2_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi2_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi2_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi2_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_xi4_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_xi4_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_xi4_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_xi4_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xi4_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi0_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi0_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi0_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi0_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi0_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi2_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi2_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi2_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi2_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi2_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi4_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi4_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi4_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi4_log" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi4_log(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi0_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi0_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi0_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi0_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi0_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi2_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi2_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi2_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi2_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi2_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_xi4_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_xi4_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_xi4_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_xi4_lin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_xi4_lin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_quad",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_quad" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_quad" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->quad(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_quad",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_quad" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_quad" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_quad(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rMIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_rMIN",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rMIN" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->rMIN();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rMAX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_rMAX",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rMAX" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->rMAX();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rMAX_eff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_rMAX_eff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rMAX_eff" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->rMAX_eff();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rr_bias_lin_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rr_bias_lin_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rr_bias_lin_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rr_bias_lin_xi" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rr_bias_lin_xi(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_bias_lin_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_bias_lin_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_bias_lin_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_bias_lin_xi" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->bias_lin_xi(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_bias_lin_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_bias_lin_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_bias_lin_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_bias_lin_xi" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_bias_lin_xi(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rr_bias_nl_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rr_bias_nl_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rr_bias_nl_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rr_bias_nl_xi" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rr_bias_nl_xi(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_bias_nl_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_bias_nl_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_bias_nl_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_bias_nl_xi" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->bias_nl_xi(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_bias_nl_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_bias_nl_xi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_bias_nl_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_bias_nl_xi" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_bias_nl_xi(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rr_bias_lin_wp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rr_bias_lin_wp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rr_bias_lin_wp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rr_bias_lin_wp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rr_bias_lin_wp(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_bias_lin_wp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_bias_lin_wp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_bias_lin_wp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_bias_lin_wp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->bias_lin_wp(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_bias_lin_wp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_bias_lin_wp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_bias_lin_wp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_bias_lin_wp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_bias_lin_wp(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_rr_bias_nl_wp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_rr_bias_nl_wp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_rr_bias_nl_wp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_rr_bias_nl_wp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rr_bias_nl_wp(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_bias_nl_wp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_bias_nl_wp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_bias_nl_wp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_bias_nl_wp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->bias_nl_wp(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_error_bias_nl_wp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_error_bias_nl_wp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_error_bias_nl_wp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_error_bias_nl_wp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->error_bias_nl_wp(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_bias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_bias",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_bias" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->bias();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_bias_min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_bias_min",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_bias_min" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->bias_min();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_bias_max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_bias_max",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_bias_max" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->bias_max();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_r0_linextr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_r0_linextr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_r0_linextr" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->r0_linextr();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_gamma_linextr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_gamma_linextr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_gamma_linextr" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->gamma_linextr();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi_log",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi_log();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi_lin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi_lin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi_real_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi_real_lin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi_real_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi_real_lin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi_real_lin_extr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi_real_lin_extr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi_real_lin_extr" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi_real_lin_extr();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi_real_lin_interp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi_real_lin_interp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi_real_lin_interp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi_real_lin_interp();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi_proj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi_proj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi_proj" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi_proj();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi0_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi0_log",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi0_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi0_log();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi2_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi2_log",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi2_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi2_log();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi4_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi4_log",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi4_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi4_log();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi0_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi0_lin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi0_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi0_lin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi2_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi2_lin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi2_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi2_lin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_xi4_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_xi4_lin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_xi4_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_xi4_lin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_quad",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_quad" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_quad();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_bias_lin_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_bias_lin_xi",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_bias_lin_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_bias_lin_xi();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_bias_nl_xi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_bias_nl_xi",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_bias_nl_xi" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_bias_nl_xi();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_bias_lin_wp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_bias_lin_wp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_bias_lin_wp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_bias_lin_wp();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_sizeof_bias_nl_wp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_sizeof_bias_nl_wp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_sizeof_bias_nl_wp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->sizeof_bias_nl_wp();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_bin_proj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_bin_proj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_bin_proj" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->bin_proj();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_nObjects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_nObjects",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_nObjects" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (int)(arg1)->nObjects();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Xmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_Xmin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_Xmin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->Xmin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Xmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_Xmax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_Xmax" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->Xmax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Ymin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_Ymin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_Ymin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->Ymin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Ymax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_Ymax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_Ymax" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->Ymax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Zmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_Zmin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_Zmin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->Zmin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_Zmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TwoPointCorrelation_Zmax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_Zmax" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  result = (double)(arg1)->Zmax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_nGal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_nGal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_nGal" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_set_nGal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nGal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_nRan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_nRan",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_nRan" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TwoPointCorrelation_set_nRan" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_nRan(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_rad_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_rad_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_rad_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_rad_log" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_rad_log" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_rad_log(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_xi_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_xi_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_xi_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_xi_log" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_log" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_xi_log(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_error_xi_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_error_xi_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_error_xi_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_error_xi_log" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_error_xi_log" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_error_xi_log(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_rad_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_rad_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_rad_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_rad_lin" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_rad_lin" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_rad_lin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_xi_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_xi_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_xi_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_xi_lin" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_lin" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_xi_lin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_error_xi_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_error_xi_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_error_xi_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_error_xi_lin" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_error_xi_lin" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_error_xi_lin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_error_xi_2d_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_error_xi_2d_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_error_xi_2d_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_error_xi_2d_lin" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_error_xi_2d_lin" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_error_xi_2d_lin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_error_xi_2d_loglin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_error_xi_2d_loglin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_error_xi_2d_loglin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_error_xi_2d_loglin" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_error_xi_2d_loglin" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_error_xi_2d_loglin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_error_xi_coslog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_error_xi_coslog",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_error_xi_coslog" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_error_xi_coslog" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_error_xi_coslog" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_error_xi_coslog(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_error_xi_coslin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_error_xi_coslin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_error_xi_coslin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_error_xi_coslin" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_error_xi_coslin" "', argument " "2"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_error_xi_coslin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_error_proj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_error_proj",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_error_proj" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_error_proj" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_error_proj" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_error_proj(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_correlations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg4 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg5 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg6 ;
  SwigValueWrapper< std::vector< std::vector< double > > > arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:TwoPointCorrelation_set_correlations",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_correlations" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_correlations" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_correlations" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_set_correlations" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_correlations" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_set_correlations" "', argument " "4"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_correlations" "', argument " "4"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TwoPointCorrelation_set_correlations" "', argument " "5"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_correlations" "', argument " "5"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TwoPointCorrelation_set_correlations" "', argument " "6"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_correlations" "', argument " "6"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TwoPointCorrelation_set_correlations" "', argument " "7"" of type '" "std::vector< std::vector< double > >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_correlations" "', argument " "7"" of type '" "std::vector< std::vector< double > >""'");
    } else {
      std::vector< std::vector< double > > * temp = reinterpret_cast< std::vector< std::vector< double > > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  (arg1)->set_correlations(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_xi_real_log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_xi_real_log",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_xi_real_log" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_xi_real_log" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_real_log" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_xi_real_log(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_xi_real_lin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_xi_real_lin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_xi_real_lin" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_xi_real_lin" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_real_lin" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_xi_real_lin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_xi_real_lin_interp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_xi_real_lin_interp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_xi_real_lin_interp" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_xi_real_lin_interp" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_real_lin_interp" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_xi_real_lin_interp(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_xi_real_lin_extr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TwoPointCorrelation_set_xi_real_lin_extr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_xi_real_lin_extr" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_xi_real_lin_extr" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_real_lin_extr" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->set_xi_real_lin_extr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TwoPointCorrelation_set_xi_proj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::TwoPointCorrelation *arg1 = (cosmobl::TwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TwoPointCorrelation_set_xi_proj",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__TwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TwoPointCorrelation_set_xi_proj" "', argument " "1"" of type '" "cosmobl::TwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::TwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TwoPointCorrelation_set_xi_proj" "', argument " "2"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_proj" "', argument " "2"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TwoPointCorrelation_set_xi_proj" "', argument " "3"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_proj" "', argument " "3"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TwoPointCorrelation_set_xi_proj" "', argument " "4"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TwoPointCorrelation_set_xi_proj" "', argument " "4"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  (arg1)->set_xi_proj(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TwoPointCorrelation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__TwoPointCorrelation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ModelTwoPointCorrelation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ModelTwoPointCorrelation")) SWIG_fail;
  result = (cosmobl::ModelTwoPointCorrelation *)new cosmobl::ModelTwoPointCorrelation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelTwoPointCorrelation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::TwoPointCorrelation > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::ModelTwoPointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ModelTwoPointCorrelation",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModelTwoPointCorrelation" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::TwoPointCorrelation >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ModelTwoPointCorrelation" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::TwoPointCorrelation >""'");
    } else {
      std::shared_ptr< cosmobl::TwoPointCorrelation > * temp = reinterpret_cast< std::shared_ptr< cosmobl::TwoPointCorrelation > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (cosmobl::ModelTwoPointCorrelation *)new cosmobl::ModelTwoPointCorrelation(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelTwoPointCorrelation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ModelTwoPointCorrelation__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModelTwoPointCorrelation__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ModelTwoPointCorrelation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::ModelTwoPointCorrelation()\n"
    "    cosmobl::ModelTwoPointCorrelation::ModelTwoPointCorrelation(std::shared_ptr< cosmobl::TwoPointCorrelation >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ModelTwoPointCorrelation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ModelTwoPointCorrelation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelTwoPointCorrelation" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_setLimit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ModelTwoPointCorrelation_setLimit",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_setLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelTwoPointCorrelation_setLimit" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ModelTwoPointCorrelation_setLimit" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setLimit(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_setLimitLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ModelTwoPointCorrelation_setLimitLog",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_setLimitLog" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelTwoPointCorrelation_setLimitLog" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ModelTwoPointCorrelation_setLimitLog" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setLimitLog(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_setLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ModelTwoPointCorrelation_setLimit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_setLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelTwoPointCorrelation_setLimit" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ModelTwoPointCorrelation_setLimit" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ModelTwoPointCorrelation_setLimit" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ModelTwoPointCorrelation_setLimit" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->setLimit(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_setLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ModelTwoPointCorrelation_setLimit__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ModelTwoPointCorrelation_setLimit__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_setLimit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::setLimit(double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::setLimit(double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  (arg1)->compute_xi2D_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  (arg1)->compute_xi2D_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  (arg1)->compute_xi2D_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  (arg1)->compute_xi2D_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  (arg1)->compute_xi2D_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  (arg1)->compute_xi2D_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[18] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 17) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_5(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_4(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_3(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_2(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_1(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured__SWIG_0(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_modelXiMeasured(std::vector< std::vector< double > > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_modelXiMeasured(std::vector< std::vector< double > > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_modelXiMeasured(std::vector< std::vector< double > > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_modelXiMeasured(std::vector< std::vector< double > > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_modelXiMeasured(std::vector< std::vector< double > > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_modelXiMeasured(std::vector< std::vector< double > > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  bool arg25 ;
  double arg26 ;
  std::string arg27 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  bool val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_bool(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "25"" of type '" "bool""'");
  } 
  arg25 = static_cast< bool >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj26, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "27"" of type '" "std::string""'"); 
    }
    arg27 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  bool arg25 ;
  double arg26 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  bool val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_bool(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "25"" of type '" "bool""'");
  } 
  arg25 = static_cast< bool >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  bool arg25 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  bool val25 ;
  int ecode25 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_bool(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "25"" of type '" "bool""'");
  } 
  arg25 = static_cast< bool >(val25);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ModelTwoPointCorrelation_compute_xi2D_model",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "2"" of type '" "std::vector< std::vector< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_xi2D_model" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  (arg1)->compute_xi2D_model(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_xi2D_model(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[28] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 27) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_16(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_15(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_14(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_13(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_12(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_11(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_10(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_9(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_8(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_7(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_6(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 22) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_5(self, args);
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 23) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_4(self, args);
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 24) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_3(self, args);
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 25) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_bool(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_2(self, args);
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 26) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_bool(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_1(self, args);
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 27) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_bool(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        int res = SWIG_AsPtr_std_string(argv[26], (std::string**)(0));
                                                        _v = SWIG_CheckState(res);
                                                        if (_v) {
                                                          return _wrap_ModelTwoPointCorrelation_compute_xi2D_model__SWIG_0(self, args);
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_compute_xi2D_model'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double,bool,double,std::string)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_xi2D_model(std::vector< std::vector< double > > &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  int arg22 ;
  int arg23 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  int val22 ;
  int ecode22 = 0 ;
  int val23 ;
  int ecode23 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_int(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "22"" of type '" "int""'");
  } 
  arg22 = static_cast< int >(val22);
  ecode23 = SWIG_AsVal_int(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "23"" of type '" "int""'");
  } 
  arg23 = static_cast< int >(val23);
  (arg1)->compute_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19,arg20,arg21,arg22,arg23);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  int arg22 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  int val22 ;
  int ecode22 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_int(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "22"" of type '" "int""'");
  } 
  arg22 = static_cast< int >(val22);
  (arg1)->compute_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19,arg20,arg21,arg22);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  (arg1)->compute_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  double arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  (arg1)->compute_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19,arg20);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  (arg1)->compute_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  (arg1)->compute_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  (arg1)->compute_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[24] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 23) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_6(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_5(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_4(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_3(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_2(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 22) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_int(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                return _wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_1(self, args);
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 23) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_int(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_int(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  return _wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured__SWIG_0(self, args);
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double,int,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  int arg22 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  int val22 ;
  int ecode22 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_int(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "22"" of type '" "int""'");
  } 
  arg22 = static_cast< int >(val22);
  (arg1)->compute_effective_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19,arg20,arg21,arg22);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  (arg1)->compute_effective_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  double arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  (arg1)->compute_effective_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19,arg20);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  double arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  (arg1)->compute_effective_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  bool arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  (arg1)->compute_effective_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  std::vector< double > *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  bool *arg12 = 0 ;
  int *arg13 = 0 ;
  double *arg14 = 0 ;
  std::string *arg15 = 0 ;
  double *arg16 = 0 ;
  int *arg17 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "7"" of type '" "std::vector< double > &""'"); 
  }
  arg7 = reinterpret_cast< std::vector< double > * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "12"" of type '" "bool &""'"); 
  }
  arg12 = reinterpret_cast< bool * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "14"" of type '" "double &""'"); 
  }
  arg14 = reinterpret_cast< double * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "15"" of type '" "std::string &""'"); 
  }
  arg15 = reinterpret_cast< std::string * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "16"" of type '" "double &""'"); 
  }
  arg16 = reinterpret_cast< double * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured" "', argument " "17"" of type '" "int &""'"); 
  }
  arg17 = reinterpret_cast< int * >(argp17);
  (arg1)->compute_effective_multipoles_modelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15,*arg16,*arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[23] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 22) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_5(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_4(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_3(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_2(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_1(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 22) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_bool, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_std__string, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_double, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_int, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_int(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                return _wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured__SWIG_0(self, args);
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_effective_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_effective_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_effective_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_effective_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_effective_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::compute_effective_multipoles_modelXiMeasured(std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,std::vector< double > &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  (arg1)->measure_beta_KaiserLimit_XiMeasured(*arg2,*arg3,*arg4,*arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  (arg1)->measure_beta_KaiserLimit_XiMeasured(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_KaiserLimit_XiMeasured(int &,double &,std::string &,double &,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_KaiserLimit_XiMeasured(int &,double &,std::string &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_XiMeasured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  double *arg6 = 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ModelTwoPointCorrelation_measure_beta_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  (arg1)->measure_beta_XiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_XiMeasured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  double *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ModelTwoPointCorrelation_measure_beta_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_XiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  (arg1)->measure_beta_XiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_XiMeasured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ModelTwoPointCorrelation_measure_beta_XiMeasured__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ModelTwoPointCorrelation_measure_beta_XiMeasured__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_measure_beta_XiMeasured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_XiMeasured(int &,int &,double &,std::string &,double &,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_XiMeasured(int &,int &,double &,std::string &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  int arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "10"" of type '" "std::string""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "10"" of type '" "std::string""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "10"" of type '" "std::string""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "10"" of type '" "std::string""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[14] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 13) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_4(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_3(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_2(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_1(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured__SWIG_0(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &,std::string,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &,std::string,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &,std::string,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &,std::string)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  double arg10 ;
  double arg11 ;
  int arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  cosmobl::Cosmology *arg4 = 0 ;
  double *arg5 = 0 ;
  int *arg6 = 0 ;
  double *arg7 = 0 ;
  std::string *arg8 = 0 ;
  double *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "4"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  (arg1)->measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[13] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 12) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles__SWIG_3(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles__SWIG_2(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles__SWIG_1(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles__SWIG_0(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_beta_sigma12_DispersionModel_XiMeasured_multipoles(int &,int &,cosmobl::Cosmology &,double &,int &,double &,std::string &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  double arg17 ;
  bool arg18 ;
  double arg19 ;
  std::string arg20 ;
  int arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "20"" of type '" "std::string""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode21 = SWIG_AsVal_int(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "21"" of type '" "int""'");
  } 
  arg21 = static_cast< int >(val21);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  double arg17 ;
  bool arg18 ;
  double arg19 ;
  std::string arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj19, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "20"" of type '" "std::string""'"); 
    }
    arg20 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  double arg17 ;
  bool arg18 ;
  double arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  double arg17 ;
  bool arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  int arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  int *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "4"" of type '" "std::string &""'"); 
  }
  arg4 = reinterpret_cast< std::string * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  (arg1)->measure_fsigma8_KaiserLimit(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[22] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 21) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_14(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_13(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_12(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_11(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_10(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_9(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_8(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_7(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_6(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_5(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_4(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_3(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_2(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_1(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__string, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          int res = SWIG_AsPtr_std_string(argv[19], (std::string**)(0));
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_int(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit__SWIG_0(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double,double,double,double,double,bool,double,std::string,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double,double,double,double,double,bool,double,std::string)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double,double,double,double,double,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double,double,double,double,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_KaiserLimit(cosmobl::Cosmology &,double &,std::string &,double &,std::string &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  std::string arg26 ;
  int arg27 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  int val27 ;
  int ecode27 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj25, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "26"" of type '" "std::string""'"); 
    }
    arg26 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode27 = SWIG_AsVal_int(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "27"" of type '" "int""'");
  } 
  arg27 = static_cast< int >(val27);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  std::string arg26 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj25, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "26"" of type '" "std::string""'"); 
    }
    arg26 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  bool arg24 ;
  double arg25 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  ecode25 = SWIG_AsVal_double(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "25"" of type '" "double""'");
  } 
  arg25 = static_cast< double >(val25);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  bool arg24 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  double arg20 ;
  double arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  double arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  double arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  std::string *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  bool *arg8 = 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg9 ;
  SwigValueWrapper< std::vector< double > > arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ModelTwoPointCorrelation_measure_fsigma8_bsigma8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "5"" of type '" "std::string &""'"); 
  }
  arg5 = reinterpret_cast< std::string * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "9"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_measure_fsigma8_bsigma8" "', argument " "10"" of type '" "std::vector< double >""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  (arg1)->measure_fsigma8_bsigma8(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[28] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 27) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_17(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_16(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_15(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_14(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_13(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_12(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_11(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_10(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_9(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_8(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_7(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_6(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 22) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_5(self, args);
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 23) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_4(self, args);
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 24) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_3(self, args);
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 25) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_2(self, args);
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 26) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      int res = SWIG_AsPtr_std_string(argv[25], (std::string**)(0));
                                                      _v = SWIG_CheckState(res);
                                                      if (_v) {
                                                        return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_1(self, args);
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 27) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__string, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_bool(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_double(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      int res = SWIG_AsPtr_std_string(argv[25], (std::string**)(0));
                                                      _v = SWIG_CheckState(res);
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_int(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          return _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8__SWIG_0(self, args);
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_measure_fsigma8_bsigma8'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double,double,double,double,double,bool,double,std::string,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double,double,double,double,double,bool,double,std::string)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double,double,double,double,double,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double,double,double,double,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::measure_fsigma8_bsigma8(cosmobl::Cosmology &,std::string &,double &,std::string &,int &,int &,bool &,std::vector< std::vector< double,std::allocator< double > > >,std::vector< double >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ModelTwoPointCorrelation_relative_error_beta_catalogue",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (double)(arg1)->relative_error_beta_catalogue(*arg2,*arg3,*arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ModelTwoPointCorrelation_relative_error_beta_catalogue",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->relative_error_beta_catalogue(*arg2,*arg3,*arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ModelTwoPointCorrelation_relative_error_beta_catalogue",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (double)(arg1)->relative_error_beta_catalogue(*arg2,*arg3,*arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_relative_error_beta_catalogue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::relative_error_beta_catalogue(double &,double &,double &,bool,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::relative_error_beta_catalogue(double &,double &,double &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::relative_error_beta_catalogue(double &,double &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue_box__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ModelTwoPointCorrelation_relative_error_beta_catalogue_box",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->relative_error_beta_catalogue_box(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue_box__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ModelTwoPointCorrelation_relative_error_beta_catalogue_box",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->relative_error_beta_catalogue_box(*arg2,*arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue_box__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ModelTwoPointCorrelation_relative_error_beta_catalogue_box",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_relative_error_beta_catalogue_box" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  result = (double)(arg1)->relative_error_beta_catalogue_box(*arg2,*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue_box(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue_box__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue_box__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue_box__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_relative_error_beta_catalogue_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::relative_error_beta_catalogue_box(double &,double &,bool,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::relative_error_beta_catalogue_box(double &,double &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::relative_error_beta_catalogue_box(double &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  (arg1)->write_xi2D_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  (arg1)->write_xi2D_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  (arg1)->write_xi2D_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  (arg1)->write_xi2D_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  (arg1)->write_xi2D_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  (arg1)->write_xi2D_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  int *arg8 = 0 ;
  double *arg9 = 0 ;
  std::string *arg10 = 0 ;
  double *arg11 = 0 ;
  int *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "8"" of type '" "int &""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured" "', argument " "12"" of type '" "int &""'"); 
  }
  arg12 = reinterpret_cast< int * >(argp12);
  (arg1)->write_xi2D_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[19] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 18) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_6(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_5(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_4(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_3(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_2(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_1(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_bool, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_int, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured__SWIG_0(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModelXiMeasured(std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double,int,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModelXiMeasured(std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModelXiMeasured(std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModelXiMeasured(std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModelXiMeasured(std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModelXiMeasured(std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModelXiMeasured(std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  int *arg9 = 0 ;
  double *arg10 = 0 ;
  std::string *arg11 = 0 ;
  double *arg12 = 0 ;
  int *arg13 = 0 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  int arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  arg9 = reinterpret_cast< int * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  arg11 = reinterpret_cast< std::string * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  (arg1)->write_multipoles_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  int *arg9 = 0 ;
  double *arg10 = 0 ;
  std::string *arg11 = 0 ;
  double *arg12 = 0 ;
  int *arg13 = 0 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  int arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  arg9 = reinterpret_cast< int * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  arg11 = reinterpret_cast< std::string * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  (arg1)->write_multipoles_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  int *arg9 = 0 ;
  double *arg10 = 0 ;
  std::string *arg11 = 0 ;
  double *arg12 = 0 ;
  int *arg13 = 0 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  int arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  arg9 = reinterpret_cast< int * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  arg11 = reinterpret_cast< std::string * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  (arg1)->write_multipoles_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  int *arg9 = 0 ;
  double *arg10 = 0 ;
  std::string *arg11 = 0 ;
  double *arg12 = 0 ;
  int *arg13 = 0 ;
  bool arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  arg9 = reinterpret_cast< int * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  arg11 = reinterpret_cast< std::string * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  (arg1)->write_multipoles_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  int *arg9 = 0 ;
  double *arg10 = 0 ;
  std::string *arg11 = 0 ;
  double *arg12 = 0 ;
  int *arg13 = 0 ;
  bool arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  arg9 = reinterpret_cast< int * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  arg11 = reinterpret_cast< std::string * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  (arg1)->write_multipoles_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  int *arg9 = 0 ;
  double *arg10 = 0 ;
  std::string *arg11 = 0 ;
  double *arg12 = 0 ;
  int *arg13 = 0 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  arg9 = reinterpret_cast< int * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  arg11 = reinterpret_cast< std::string * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  (arg1)->write_multipoles_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  int *arg9 = 0 ;
  double *arg10 = 0 ;
  std::string *arg11 = 0 ;
  double *arg12 = 0 ;
  int *arg13 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "9"" of type '" "int &""'"); 
  }
  arg9 = reinterpret_cast< int * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "11"" of type '" "std::string &""'"); 
  }
  arg11 = reinterpret_cast< std::string * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured" "', argument " "13"" of type '" "int &""'"); 
  }
  arg13 = reinterpret_cast< int * >(argp13);
  (arg1)->write_multipoles_DispersionModelXiMeasured(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[20] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 19) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__string, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_6(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__string, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_5(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__string, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_4(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__string, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_3(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__string, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_2(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__string, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_1(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_std__string, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured__SWIG_0(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::write_multipoles_DispersionModelXiMeasured(std::string &,std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,int,int,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_multipoles_DispersionModelXiMeasured(std::string &,std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,int,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_multipoles_DispersionModelXiMeasured(std::string &,std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_multipoles_DispersionModelXiMeasured(std::string &,std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_multipoles_DispersionModelXiMeasured(std::string &,std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_multipoles_DispersionModelXiMeasured(std::string &,std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_multipoles_DispersionModelXiMeasured(std::string &,std::string &,double &,double &,cosmobl::Cosmology &,double &,bool &,int &,double &,std::string &,double &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  bool arg25 ;
  double arg26 ;
  std::string arg27 ;
  int arg28 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  bool val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  int val28 ;
  int ecode28 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_bool(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "25"" of type '" "bool""'");
  } 
  arg25 = static_cast< bool >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj26, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "27"" of type '" "std::string""'"); 
    }
    arg27 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode28 = SWIG_AsVal_int(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "28"" of type '" "int""'");
  } 
  arg28 = static_cast< int >(val28);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  bool arg25 ;
  double arg26 ;
  std::string arg27 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  bool val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_bool(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "25"" of type '" "bool""'");
  } 
  arg25 = static_cast< bool >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj26, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "27"" of type '" "std::string""'"); 
    }
    arg27 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  bool arg25 ;
  double arg26 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  bool val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_bool(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "25"" of type '" "bool""'");
  } 
  arg25 = static_cast< bool >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  bool arg25 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  bool val25 ;
  int ecode25 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_bool(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "25"" of type '" "bool""'");
  } 
  arg25 = static_cast< bool >(val25);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  double arg22 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  double arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  double arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  double val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  ecode20 = SWIG_AsVal_double(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "20"" of type '" "double""'");
  } 
  arg20 = static_cast< double >(val20);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  int arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  ecode19 = SWIG_AsVal_int(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "19"" of type '" "int""'");
  } 
  arg19 = static_cast< int >(val19);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  int arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  double *arg7 = 0 ;
  bool *arg8 = 0 ;
  std::string *arg9 = 0 ;
  std::string *arg10 = 0 ;
  int *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_DispersionModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "6"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "8"" of type '" "bool &""'"); 
  }
  arg8 = reinterpret_cast< bool * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "10"" of type '" "std::string &""'"); 
  }
  arg10 = reinterpret_cast< std::string * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_DispersionModel" "', argument " "11"" of type '" "int &""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  (arg1)->write_xi2D_DispersionModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[29] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 28) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_17(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_16(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_15(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_14(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_13(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_12(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_11(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_10(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_9(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_8(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_7(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 22) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_6(self, args);
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 23) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_5(self, args);
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 24) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_4(self, args);
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 25) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_bool(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_3(self, args);
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 26) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_bool(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_2(self, args);
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 27) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_bool(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        int res = SWIG_AsPtr_std_string(argv[26], (std::string**)(0));
                                                        _v = SWIG_CheckState(res);
                                                        if (_v) {
                                                          return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_1(self, args);
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 28) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_bool, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_std__string, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_int, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_double(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_bool(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        int res = SWIG_AsPtr_std_string(argv[26], (std::string**)(0));
                                                        _v = SWIG_CheckState(res);
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_int(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            return _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel__SWIG_0(self, args);
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_write_xi2D_DispersionModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double,bool,double,std::string,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double,bool,double,std::string)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_DispersionModel(std::string &,double &,double &,double &,cosmobl::Cosmology &,double &,bool &,std::string &,std::string &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  int arg25 ;
  double arg26 ;
  bool arg27 ;
  double arg28 ;
  std::string arg29 ;
  int arg30 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  bool val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  int val30 ;
  int ecode30 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_bool(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "27"" of type '" "bool""'");
  } 
  arg27 = static_cast< bool >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj28, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "29"" of type '" "std::string""'"); 
    }
    arg29 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode30 = SWIG_AsVal_int(obj29, &val30);
  if (!SWIG_IsOK(ecode30)) {
    SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "30"" of type '" "int""'");
  } 
  arg30 = static_cast< int >(val30);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  int arg25 ;
  double arg26 ;
  bool arg27 ;
  double arg28 ;
  std::string arg29 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  bool val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_bool(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "27"" of type '" "bool""'");
  } 
  arg27 = static_cast< bool >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj28, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "29"" of type '" "std::string""'"); 
    }
    arg29 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  int arg25 ;
  double arg26 ;
  bool arg27 ;
  double arg28 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  bool val27 ;
  int ecode27 = 0 ;
  double val28 ;
  int ecode28 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_bool(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "27"" of type '" "bool""'");
  } 
  arg27 = static_cast< bool >(val27);
  ecode28 = SWIG_AsVal_double(obj27, &val28);
  if (!SWIG_IsOK(ecode28)) {
    SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "28"" of type '" "double""'");
  } 
  arg28 = static_cast< double >(val28);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  int arg25 ;
  double arg26 ;
  bool arg27 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  bool val27 ;
  int ecode27 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  ecode27 = SWIG_AsVal_bool(obj26, &val27);
  if (!SWIG_IsOK(ecode27)) {
    SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "27"" of type '" "bool""'");
  } 
  arg27 = static_cast< bool >(val27);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  int arg25 ;
  double arg26 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  ecode26 = SWIG_AsVal_double(obj25, &val26);
  if (!SWIG_IsOK(ecode26)) {
    SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "26"" of type '" "double""'");
  } 
  arg26 = static_cast< double >(val26);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  int arg25 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  int val25 ;
  int ecode25 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  ecode25 = SWIG_AsVal_int(obj24, &val25);
  if (!SWIG_IsOK(ecode25)) {
    SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "25"" of type '" "int""'");
  } 
  arg25 = static_cast< int >(val25);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  double arg24 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  ecode24 = SWIG_AsVal_double(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "24"" of type '" "double""'");
  } 
  arg24 = static_cast< double >(val24);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  double arg23 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  ecode23 = SWIG_AsVal_double(obj22, &val23);
  if (!SWIG_IsOK(ecode23)) {
    SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "23"" of type '" "double""'");
  } 
  arg23 = static_cast< double >(val23);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  double arg22 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  double val22 ;
  int ecode22 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  ecode22 = SWIG_AsVal_double(obj21, &val22);
  if (!SWIG_IsOK(ecode22)) {
    SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "22"" of type '" "double""'");
  } 
  arg22 = static_cast< double >(val22);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  double arg21 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  double val21 ;
  int ecode21 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  ecode21 = SWIG_AsVal_double(obj20, &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "21"" of type '" "double""'");
  } 
  arg21 = static_cast< double >(val21);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  int arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  ecode20 = SWIG_AsVal_int(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "20"" of type '" "int""'");
  } 
  arg20 = static_cast< int >(val20);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  double arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  ecode19 = SWIG_AsVal_double(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "19"" of type '" "double""'");
  } 
  arg19 = static_cast< double >(val19);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_double(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "18"" of type '" "double""'");
  } 
  arg18 = static_cast< double >(val18);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double *arg11 = 0 ;
  std::string *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ModelTwoPointCorrelation_write_xi2D_CWModel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "9"" of type '" "double &""'"); 
  }
  arg9 = reinterpret_cast< double * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_xi2D_CWModel" "', argument " "12"" of type '" "std::string &""'"); 
  }
  arg12 = reinterpret_cast< std::string * >(argp12);
  (arg1)->write_xi2D_CWModel(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_xi2D_CWModel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[31] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 30) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_18(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_17(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_16(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_15(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_14(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_13(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_12(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_11(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_10(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_9(self, args);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 22) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_8(self, args);
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 23) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_7(self, args);
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 24) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_6(self, args);
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 25) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_5(self, args);
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 26) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_4(self, args);
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 27) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_bool(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_3(self, args);
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 28) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_bool(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_2(self, args);
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 29) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_bool(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            int res = SWIG_AsPtr_std_string(argv[28], (std::string**)(0));
                                                            _v = SWIG_CheckState(res);
                                                            if (_v) {
                                                              return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_1(self, args);
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 30) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_std__string, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_double(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_double(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              {
                                                int res = SWIG_AsVal_double(argv[21], NULL);
                                                _v = SWIG_CheckState(res);
                                              }
                                              if (_v) {
                                                {
                                                  int res = SWIG_AsVal_double(argv[22], NULL);
                                                  _v = SWIG_CheckState(res);
                                                }
                                                if (_v) {
                                                  {
                                                    int res = SWIG_AsVal_double(argv[23], NULL);
                                                    _v = SWIG_CheckState(res);
                                                  }
                                                  if (_v) {
                                                    {
                                                      int res = SWIG_AsVal_int(argv[24], NULL);
                                                      _v = SWIG_CheckState(res);
                                                    }
                                                    if (_v) {
                                                      {
                                                        int res = SWIG_AsVal_double(argv[25], NULL);
                                                        _v = SWIG_CheckState(res);
                                                      }
                                                      if (_v) {
                                                        {
                                                          int res = SWIG_AsVal_bool(argv[26], NULL);
                                                          _v = SWIG_CheckState(res);
                                                        }
                                                        if (_v) {
                                                          {
                                                            int res = SWIG_AsVal_double(argv[27], NULL);
                                                            _v = SWIG_CheckState(res);
                                                          }
                                                          if (_v) {
                                                            int res = SWIG_AsPtr_std_string(argv[28], (std::string**)(0));
                                                            _v = SWIG_CheckState(res);
                                                            if (_v) {
                                                              {
                                                                int res = SWIG_AsVal_int(argv[29], NULL);
                                                                _v = SWIG_CheckState(res);
                                                              }
                                                              if (_v) {
                                                                return _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel__SWIG_0(self, args);
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_write_xi2D_CWModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double,double,double,int,double,bool,double,std::string,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double,double,double,int,double,bool,double,std::string)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double,double,double,int,double,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double,double,double,int,double,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double,double,double,int,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool,double)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_xi2D_CWModel(std::string &,double &,double &,double &,double &,double &,double &,double &,cosmobl::Cosmology &,double &,std::string &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_map__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg2 ;
  std::string *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ModelTwoPointCorrelation_write_map",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->write_map(arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_map__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ModelTwoPointCorrelation_write_map",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > >""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_write_map" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  (arg1)->write_map(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_write_map(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelTwoPointCorrelation_write_map__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ModelTwoPointCorrelation_write_map__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_write_map'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::write_map(std::vector< std::vector< double,std::allocator< double > > >,std::string &,int)\n"
    "    cosmobl::ModelTwoPointCorrelation::write_map(std::vector< std::vector< double,std::allocator< double > > >,std::string &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_MhaloMin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  std::string *arg7 = 0 ;
  std::string *arg8 = 0 ;
  std::string *arg9 = 0 ;
  double *arg10 = 0 ;
  double *arg11 = 0 ;
  double *arg12 = 0 ;
  double *arg13 = 0 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:ModelTwoPointCorrelation_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "7"" of type '" "std::string &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "7"" of type '" "std::string &""'"); 
  }
  arg7 = reinterpret_cast< std::string * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "13"" of type '" "double &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "13"" of type '" "double &""'"); 
  }
  arg13 = reinterpret_cast< double * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  result = (double)(arg1)->MhaloMin(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,arg14,arg15);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_MhaloMin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  std::string *arg7 = 0 ;
  std::string *arg8 = 0 ;
  std::string *arg9 = 0 ;
  double *arg10 = 0 ;
  double *arg11 = 0 ;
  double *arg12 = 0 ;
  double *arg13 = 0 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ModelTwoPointCorrelation_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "7"" of type '" "std::string &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "7"" of type '" "std::string &""'"); 
  }
  arg7 = reinterpret_cast< std::string * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "13"" of type '" "double &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "13"" of type '" "double &""'"); 
  }
  arg13 = reinterpret_cast< double * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  result = (double)(arg1)->MhaloMin(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,arg14);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_MhaloMin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  cosmobl::Cosmology *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  std::string *arg6 = 0 ;
  std::string *arg7 = 0 ;
  std::string *arg8 = 0 ;
  std::string *arg9 = 0 ;
  double *arg10 = 0 ;
  double *arg11 = 0 ;
  double *arg12 = 0 ;
  double *arg13 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:ModelTwoPointCorrelation_MhaloMin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "2"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "6"" of type '" "std::string &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "6"" of type '" "std::string &""'"); 
  }
  arg6 = reinterpret_cast< std::string * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "7"" of type '" "std::string &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "7"" of type '" "std::string &""'"); 
  }
  arg7 = reinterpret_cast< std::string * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "8"" of type '" "std::string &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "8"" of type '" "std::string &""'"); 
  }
  arg8 = reinterpret_cast< std::string * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "9"" of type '" "std::string &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "9"" of type '" "std::string &""'"); 
  }
  arg9 = reinterpret_cast< std::string * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "11"" of type '" "double &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "11"" of type '" "double &""'"); 
  }
  arg11 = reinterpret_cast< double * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "12"" of type '" "double &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "12"" of type '" "double &""'"); 
  }
  arg12 = reinterpret_cast< double * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "13"" of type '" "double &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelTwoPointCorrelation_MhaloMin" "', argument " "13"" of type '" "double &""'"); 
  }
  arg13 = reinterpret_cast< double * >(argp13);
  result = (double)(arg1)->MhaloMin(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11,*arg12,*arg13);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_MhaloMin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[16] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 15) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__string, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_double, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_ModelTwoPointCorrelation_MhaloMin__SWIG_2(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__string, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_double, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_ModelTwoPointCorrelation_MhaloMin__SWIG_1(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__string, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_std__string, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_std__string, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_std__string, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_double, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_ModelTwoPointCorrelation_MhaloMin__SWIG_0(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ModelTwoPointCorrelation_MhaloMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ModelTwoPointCorrelation::MhaloMin(cosmobl::Cosmology &,double &,double &,double &,std::string &,std::string &,std::string &,std::string &,double &,double &,double &,double &,bool,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::MhaloMin(cosmobl::Cosmology &,double &,double &,double &,std::string &,std::string &,std::string &,std::string &,double &,double &,double &,double &,bool)\n"
    "    cosmobl::ModelTwoPointCorrelation::MhaloMin(cosmobl::Cosmology &,double &,double &,double &,std::string &,std::string &,std::string &,std::string &,double &,double &,double &,double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_beta_best(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_beta_best",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_beta_best" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->beta_best();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_error_beta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_error_beta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_error_beta" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->error_beta();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_sigma12_best(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_sigma12_best",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_sigma12_best" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->sigma12_best();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_error_sigma12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_error_sigma12",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_error_sigma12" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->error_sigma12();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_bias_best(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_bias_best",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_bias_best" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->bias_best();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_bias_sigma8_best(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_bias_sigma8_best",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_bias_sigma8_best" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->bias_sigma8_best();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_f_sigma8_best(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_f_sigma8_best",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_f_sigma8_best" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->f_sigma8_best();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_bA_best(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_bA_best",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_bA_best" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->bA_best();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelTwoPointCorrelation_E_min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ModelTwoPointCorrelation *arg1 = (cosmobl::ModelTwoPointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ModelTwoPointCorrelation_E_min",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelTwoPointCorrelation_E_min" "', argument " "1"" of type '" "cosmobl::ModelTwoPointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ModelTwoPointCorrelation * >(argp1);
  result = (double)(arg1)->E_min();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ModelTwoPointCorrelation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__ModelTwoPointCorrelation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_STR_xi0K_cosm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  cosmobl::Cosmology *arg2 = (cosmobl::Cosmology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_cosm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_cosm_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi0K_cosm_set" "', argument " "2"" of type '" "cosmobl::Cosmology *""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  if (arg1) (arg1)->cosm = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_cosm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  cosmobl::Cosmology *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_cosm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_cosm_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (cosmobl::Cosmology *)& ((arg1)->cosm);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Cosmology, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_bias_sigma8_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_bias_sigma8_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_bias_sigma8_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_bias_sigma8_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->bias_sigma8 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_bias_sigma8_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_bias_sigma8_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_bias_sigma8_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->bias_sigma8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_author_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_author_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_author_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi0K_author_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_xi0K_author_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->author = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_author_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_author_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_author_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (std::string *) & ((arg1)->author);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_redshift_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_redshift_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_redshift_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_redshift_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->redshift = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_redshift_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_redshift_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_redshift_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->redshift);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_Model_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_Model_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_Model_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi0K_Model_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_xi0K_Model_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->Model = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_Model_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_Model_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_Model_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (std::string *) & ((arg1)->Model);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_xiType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_xiType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_xiType_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_xiType_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->xiType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_xiType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_xiType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_xiType_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (bool) ((arg1)->xiType);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_k_star_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_k_star_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_k_star_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_k_star_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->k_star = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_k_star_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_k_star_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_k_star_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->k_star);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_xiNL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_xiNL_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_xiNL_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_xiNL_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->xiNL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_xiNL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_xiNL_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_xiNL_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (bool) ((arg1)->xiNL);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_v_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_v_min_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_v_min_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_v_min_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->v_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_v_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_v_min_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_v_min_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->v_min);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_v_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_v_max_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_v_max_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_v_max_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->v_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_v_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_v_max_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_v_max_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->v_max);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_step_v_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_step_v_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_step_v_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_step_v_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->step_v = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_step_v_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_step_v_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_step_v_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (int) ((arg1)->step_v);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_norm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_norm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_norm_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_norm_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->norm = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_norm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_norm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_norm_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (int) ((arg1)->norm);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_r_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_r_min_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_r_min_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_r_min_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->r_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_r_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_r_min_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_r_min_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->r_min);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_r_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_r_max_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_r_max_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_r_max_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->r_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_r_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_r_max_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_r_max_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->r_max);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_k_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_k_min_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_k_min_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_k_min_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->k_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_k_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_k_min_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_k_min_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->k_min);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_k_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_k_max_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_k_max_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_k_max_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->k_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_k_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_k_max_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_k_max_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->k_max);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_aa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_aa_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_aa_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_aa_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->aa = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_aa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_aa_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_aa_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->aa);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_GSL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_GSL_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_GSL_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_GSL_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->GSL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_GSL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_GSL_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_GSL_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (bool) ((arg1)->GSL);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_prec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_prec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_prec_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "STR_xi0K_prec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->prec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_prec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_prec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_prec_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (double) ((arg1)->prec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_file_par_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:STR_xi0K_file_par_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_file_par_set" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STR_xi0K_file_par_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "STR_xi0K_file_par_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->file_par = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_STR_xi0K_file_par_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:STR_xi0K_file_par_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STR_xi0K_file_par_get" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  result = (std::string *) & ((arg1)->file_par);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_STR_xi0K(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_STR_xi0K")) SWIG_fail;
  result = (cosmobl::glob::STR_xi0K *)new cosmobl::glob::STR_xi0K();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__glob__STR_xi0K, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_STR_xi0K(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::glob::STR_xi0K *arg1 = (cosmobl::glob::STR_xi0K *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_STR_xi0K",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__glob__STR_xi0K, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_STR_xi0K" "', argument " "1"" of type '" "cosmobl::glob::STR_xi0K *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::glob::STR_xi0K * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *STR_xi0K_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__glob__STR_xi0K, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Triplets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Triplets",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Triplets" "', argument " "1"" of type '" "cosmobl::Triplets *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_binsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets_binsize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_binsize" "', argument " "1"" of type '" "cosmobl::Triplets const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  result = (double)((cosmobl::Triplets const *)arg1)->binsize();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_side_s(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets_side_s",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_side_s" "', argument " "1"" of type '" "cosmobl::Triplets const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  result = (double)((cosmobl::Triplets const *)arg1)->side_s();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_side_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets_side_u",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_side_u" "', argument " "1"" of type '" "cosmobl::Triplets const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  result = (double)((cosmobl::Triplets const *)arg1)->side_u();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_perc_increase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets_perc_increase",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_perc_increase" "', argument " "1"" of type '" "cosmobl::Triplets const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  result = (double)((cosmobl::Triplets const *)arg1)->perc_increase();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_TT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Triplets_TT",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_TT" "', argument " "1"" of type '" "cosmobl::Triplets const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets_TT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Triplets const *)arg1)->TT(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_TT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets_TT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_TT" "', argument " "1"" of type '" "cosmobl::Triplets const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  result = ((cosmobl::Triplets const *)arg1)->TT();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_TT(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Triplets_TT__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Triplets_TT__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets_TT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets::TT(int const) const\n"
    "    cosmobl::Triplets::TT() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Triplets_sum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Triplets > > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Triplets_sum",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_sum" "', argument " "1"" of type '" "cosmobl::Triplets *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'");
    } else {
      std::shared_ptr< cosmobl::Triplets > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Triplets > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets_sum" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_sum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Triplets > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Triplets_sum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_sum" "', argument " "1"" of type '" "cosmobl::Triplets *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'");
    } else {
      std::shared_ptr< cosmobl::Triplets > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Triplets > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->sum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_sum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Triplets_sum__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Triplets_sum__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets_sum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets::sum(std::shared_ptr< cosmobl::Triplets > const,double const)\n"
    "    cosmobl::Triplets::sum(std::shared_ptr< cosmobl::Triplets > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Triplets_put__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Triplets_put",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_put" "', argument " "1"" of type '" "cosmobl::Triplets *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets_put" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets_put" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Triplets_put" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Triplets_put" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->put(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_put__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Triplets_put",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_put" "', argument " "1"" of type '" "cosmobl::Triplets *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets_put" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets_put" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Triplets_put" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->put(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_put__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *arg1 = (cosmobl::Triplets *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  std::shared_ptr< cosmobl::Object > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Triplets_put",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets_put" "', argument " "1"" of type '" "cosmobl::Triplets *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets_put" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets_put" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Triplets_put" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets_put" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Triplets_put" "', argument " "4"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets_put" "', argument " "4"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  (arg1)->put(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets_put(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Triplets_put__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Triplets_put__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Triplets_put__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets_put'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets::put(double const,double const,double const,double const)\n"
    "    cosmobl::Triplets::put(double const,double const,double const)\n"
    "    cosmobl::Triplets::put(std::shared_ptr< cosmobl::Object > const,std::shared_ptr< cosmobl::Object > const,std::shared_ptr< cosmobl::Object > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Triplets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Triplets")) SWIG_fail;
  result = (cosmobl::Triplets *)new cosmobl::Triplets();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Triplets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Triplets_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Triplets, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Triplets2D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Triplets2D")) SWIG_fail;
  result = (cosmobl::Triplets2D *)new cosmobl::Triplets2D();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Triplets2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Triplets2D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Triplets2D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Triplets2D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Triplets2D" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Triplets2D" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Triplets2D" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Triplets2D" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Triplets2D" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Triplets2D *)new cosmobl::Triplets2D(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Triplets2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Triplets2D(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Triplets2D__SWIG_0(self, args);
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Triplets2D__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Triplets2D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets2D::Triplets2D()\n"
    "    cosmobl::Triplets2D::Triplets2D(std::string const,double const,double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Triplets2D_binsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets2D_binsize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_binsize" "', argument " "1"" of type '" "cosmobl::Triplets2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  result = (double)((cosmobl::Triplets2D const *)arg1)->binsize();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_side_s(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets2D_side_s",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_side_s" "', argument " "1"" of type '" "cosmobl::Triplets2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  result = (double)((cosmobl::Triplets2D const *)arg1)->side_s();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_side_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets2D_side_u",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_side_u" "', argument " "1"" of type '" "cosmobl::Triplets2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  result = (double)((cosmobl::Triplets2D const *)arg1)->side_u();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_perc_increase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets2D_perc_increase",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_perc_increase" "', argument " "1"" of type '" "cosmobl::Triplets2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  result = (double)((cosmobl::Triplets2D const *)arg1)->perc_increase();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_TT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Triplets2D_TT",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_TT" "', argument " "1"" of type '" "cosmobl::Triplets2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets2D_TT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Triplets2D const *)arg1)->TT(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_TT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets2D_TT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_TT" "', argument " "1"" of type '" "cosmobl::Triplets2D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  result = ((cosmobl::Triplets2D const *)arg1)->TT();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_TT(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Triplets2D_TT__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Triplets2D_TT__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets2D_TT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets2D::TT(int const) const\n"
    "    cosmobl::Triplets2D::TT() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Triplets2D_sum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Triplets > > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Triplets2D_sum",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_sum" "', argument " "1"" of type '" "cosmobl::Triplets2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets2D_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets2D_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'");
    } else {
      std::shared_ptr< cosmobl::Triplets > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Triplets > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets2D_sum" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_sum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Triplets > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Triplets2D_sum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_sum" "', argument " "1"" of type '" "cosmobl::Triplets2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets2D_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets2D_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'");
    } else {
      std::shared_ptr< cosmobl::Triplets > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Triplets > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->sum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_sum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Triplets2D_sum__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Triplets2D_sum__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets2D_sum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets2D::sum(std::shared_ptr< cosmobl::Triplets > const,double const)\n"
    "    cosmobl::Triplets2D::sum(std::shared_ptr< cosmobl::Triplets > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Triplets2D_put__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Triplets2D_put",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_put" "', argument " "1"" of type '" "cosmobl::Triplets2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets2D_put" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets2D_put" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Triplets2D_put" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Triplets2D_put" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->put(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_put__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Triplets2D_put",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_put" "', argument " "1"" of type '" "cosmobl::Triplets2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets2D_put" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets2D_put" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Triplets2D_put" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->put(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_put__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  std::shared_ptr< cosmobl::Object > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Triplets2D_put",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets2D_put" "', argument " "1"" of type '" "cosmobl::Triplets2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets2D_put" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets2D_put" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Triplets2D_put" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets2D_put" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Triplets2D_put" "', argument " "4"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets2D_put" "', argument " "4"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  (arg1)->put(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets2D_put(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Triplets2D_put__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Triplets2D_put__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Triplets2D_put__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets2D_put'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets2D::put(double const,double const,double const,double const)\n"
    "    cosmobl::Triplets2D::put(double const,double const,double const)\n"
    "    cosmobl::Triplets2D::put(std::shared_ptr< cosmobl::Object > const,std::shared_ptr< cosmobl::Object > const,std::shared_ptr< cosmobl::Object > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Triplets2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets2D *arg1 = (cosmobl::Triplets2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Triplets2D",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Triplets2D" "', argument " "1"" of type '" "cosmobl::Triplets2D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets2D * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Triplets2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Triplets2D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Triplets3D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Triplets3D")) SWIG_fail;
  result = (cosmobl::Triplets3D *)new cosmobl::Triplets3D();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Triplets3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Triplets3D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  cosmobl::Triplets3D *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Triplets3D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Triplets3D" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Triplets3D" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Triplets3D" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Triplets3D" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Triplets3D" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (cosmobl::Triplets3D *)new cosmobl::Triplets3D(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__Triplets3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Triplets3D(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Triplets3D__SWIG_0(self, args);
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Triplets3D__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Triplets3D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets3D::Triplets3D()\n"
    "    cosmobl::Triplets3D::Triplets3D(std::string const,double const,double const,double const,double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Triplets3D_binsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets3D_binsize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_binsize" "', argument " "1"" of type '" "cosmobl::Triplets3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  result = (double)((cosmobl::Triplets3D const *)arg1)->binsize();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_side_s(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets3D_side_s",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_side_s" "', argument " "1"" of type '" "cosmobl::Triplets3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  result = (double)((cosmobl::Triplets3D const *)arg1)->side_s();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_side_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets3D_side_u",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_side_u" "', argument " "1"" of type '" "cosmobl::Triplets3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  result = (double)((cosmobl::Triplets3D const *)arg1)->side_u();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_perc_increase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets3D_perc_increase",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_perc_increase" "', argument " "1"" of type '" "cosmobl::Triplets3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  result = (double)((cosmobl::Triplets3D const *)arg1)->perc_increase();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_TT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Triplets3D_TT",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_TT" "', argument " "1"" of type '" "cosmobl::Triplets3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets3D_TT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((cosmobl::Triplets3D const *)arg1)->TT(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_TT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Triplets3D_TT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_TT" "', argument " "1"" of type '" "cosmobl::Triplets3D const *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  result = ((cosmobl::Triplets3D const *)arg1)->TT();
  resultobj = SWIG_NewPointerObj((new std::vector< double >(static_cast< const std::vector< double >& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_TT(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Triplets3D_TT__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Triplets3D_TT__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets3D_TT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets3D::TT(int const) const\n"
    "    cosmobl::Triplets3D::TT() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Triplets3D_sum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Triplets > > arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Triplets3D_sum",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_sum" "', argument " "1"" of type '" "cosmobl::Triplets3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets3D_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets3D_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'");
    } else {
      std::shared_ptr< cosmobl::Triplets > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Triplets > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets3D_sum" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->sum(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_sum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Triplets > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Triplets3D_sum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_sum" "', argument " "1"" of type '" "cosmobl::Triplets3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets3D_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets3D_sum" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Triplets > const""'");
    } else {
      std::shared_ptr< cosmobl::Triplets > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Triplets > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->sum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_sum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Triplets3D_sum__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Triplets_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Triplets3D_sum__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets3D_sum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets3D::sum(std::shared_ptr< cosmobl::Triplets > const,double const)\n"
    "    cosmobl::Triplets3D::sum(std::shared_ptr< cosmobl::Triplets > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Triplets3D_put__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Triplets3D_put",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_put" "', argument " "1"" of type '" "cosmobl::Triplets3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets3D_put" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets3D_put" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Triplets3D_put" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Triplets3D_put" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->put(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_put__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Triplets3D_put",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_put" "', argument " "1"" of type '" "cosmobl::Triplets3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Triplets3D_put" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Triplets3D_put" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Triplets3D_put" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->put(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_put__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  std::shared_ptr< cosmobl::Object > arg2 ;
  std::shared_ptr< cosmobl::Object > arg3 ;
  std::shared_ptr< cosmobl::Object > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Triplets3D_put",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Triplets3D_put" "', argument " "1"" of type '" "cosmobl::Triplets3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Triplets3D_put" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets3D_put" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Triplets3D_put" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets3D_put" "', argument " "3"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Triplets3D_put" "', argument " "4"" of type '" "std::shared_ptr< cosmobl::Object > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Triplets3D_put" "', argument " "4"" of type '" "std::shared_ptr< cosmobl::Object > const""'");
    } else {
      std::shared_ptr< cosmobl::Object > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Object > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  (arg1)->put(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Triplets3D_put(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Object_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Triplets3D_put__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Triplets3D_put__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__Triplets3D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Triplets3D_put__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Triplets3D_put'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Triplets3D::put(double const,double const,double const,double const)\n"
    "    cosmobl::Triplets3D::put(double const,double const,double const)\n"
    "    cosmobl::Triplets3D::put(std::shared_ptr< cosmobl::Object > const,std::shared_ptr< cosmobl::Object > const,std::shared_ptr< cosmobl::Object > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Triplets3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::Triplets3D *arg1 = (cosmobl::Triplets3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Triplets3D",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__Triplets3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Triplets3D" "', argument " "1"" of type '" "cosmobl::Triplets3D *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::Triplets3D * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Triplets3D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__Triplets3D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ThreePointCorrelation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ThreePointCorrelation")) SWIG_fail;
  result = (cosmobl::ThreePointCorrelation *)new cosmobl::ThreePointCorrelation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ThreePointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThreePointCorrelation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  cosmobl::ThreePointCorrelation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ThreePointCorrelation",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThreePointCorrelation" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ThreePointCorrelation" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ThreePointCorrelation" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ThreePointCorrelation" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue > const""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (cosmobl::ThreePointCorrelation *)new cosmobl::ThreePointCorrelation(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cosmobl__ThreePointCorrelation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThreePointCorrelation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ThreePointCorrelation__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ThreePointCorrelation__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ThreePointCorrelation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ThreePointCorrelation::ThreePointCorrelation()\n"
    "    cosmobl::ThreePointCorrelation::ThreePointCorrelation(std::shared_ptr< cosmobl::Catalogue > const,std::shared_ptr< cosmobl::Catalogue > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ThreePointCorrelation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ThreePointCorrelation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThreePointCorrelation" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_setParameters3p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  std::string arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ThreePointCorrelation_setParameters3p",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_setParameters3p" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThreePointCorrelation_setParameters3p" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ThreePointCorrelation_setParameters3p" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ThreePointCorrelation_setParameters3p" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_setParameters3p" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_setParameters3p" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->setParameters3p(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_allocate_vectors_zeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ThreePointCorrelation_allocate_vectors_zeta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_allocate_vectors_zeta" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  (arg1)->allocate_vectors_zeta();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  (arg1)->measure_Q(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  (arg1)->measure_Q(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->measure_Q(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->measure_Q(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->measure_Q(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  (arg1)->measure_Q(arg2,arg3,(std::vector< std::string > const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_Q(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ThreePointCorrelation_measure_Q",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_Q(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ThreePointCorrelation_measure_Q",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  (arg1)->measure_Q();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->measure_Q(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::string > > arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ThreePointCorrelation_measure_Q",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::vector< std::string >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q" "', argument " "2"" of type '" "std::vector< std::string >""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ThreePointCorrelation_measure_Q" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->measure_Q(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ThreePointCorrelation_measure_Q__SWIG_8(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ThreePointCorrelation_measure_Q__SWIG_7(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ThreePointCorrelation_measure_Q__SWIG_10(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ThreePointCorrelation_measure_Q__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ThreePointCorrelation_measure_Q__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ThreePointCorrelation_measure_Q__SWIG_9(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ThreePointCorrelation_measure_Q__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ThreePointCorrelation_measure_Q__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ThreePointCorrelation_measure_Q__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ThreePointCorrelation_measure_Q__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ThreePointCorrelation_measure_Q__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ThreePointCorrelation_measure_Q'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const,std::string const,std::vector< std::string > const &,int const,int const,int const,int const,bool const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const,std::string const,std::vector< std::string > const &,int const,int const,int const,int const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const,std::string const,std::vector< std::string > const &,int const,int const,int const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const,std::string const,std::vector< std::string > const &,int const,int const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const,std::string const,std::vector< std::string > const &,int const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const,std::string const,std::vector< std::string > const &)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const,std::string const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q()\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::string const,std::string const,bool const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q(std::vector< std::string >,bool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ThreePointCorrelation_measure_Q_TEST",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->measure_Q_TEST(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ThreePointCorrelation_measure_Q_TEST",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->measure_Q_TEST(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ThreePointCorrelation_measure_Q_TEST",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  (arg1)->measure_Q_TEST(arg2,arg3,(std::vector< std::string > const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ThreePointCorrelation_measure_Q_TEST",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_Q_TEST(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ThreePointCorrelation_measure_Q_TEST",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_Q_TEST(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ThreePointCorrelation_measure_Q_TEST",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_TEST" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  (arg1)->measure_Q_TEST();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_TEST(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ThreePointCorrelation_measure_Q_TEST__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ThreePointCorrelation_measure_Q_TEST'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_TEST(std::string const,std::string const,std::vector< std::string > const &,bool const,bool const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_TEST(std::string const,std::string const,std::vector< std::string > const &,bool const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_TEST(std::string const,std::string const,std::vector< std::string > const &)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_TEST(std::string const,std::string const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_TEST(std::string const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_TEST()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  (arg1)->measure_Q_ang(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  (arg1)->measure_Q_ang(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->measure_Q_ang(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->measure_Q_ang(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->measure_Q_ang(arg2,arg3,(std::vector< std::string > const &)*arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "std::vector< std::string > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  (arg1)->measure_Q_ang(arg2,arg3,(std::vector< std::string > const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_Q_ang(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->measure_Q_ang(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ThreePointCorrelation_measure_Q_ang",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  (arg1)->measure_Q_ang();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->measure_Q_ang(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  SwigValueWrapper< std::vector< std::string > > arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ThreePointCorrelation_measure_Q_ang",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::vector< std::string > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "2"" of type '" "std::vector< std::string > const""'");
    } else {
      std::vector< std::string > * temp = reinterpret_cast< std::vector< std::string > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ThreePointCorrelation_measure_Q_ang" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->measure_Q_ang(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_measure_Q_ang(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_8(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_7(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_10(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_9(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ThreePointCorrelation_measure_Q_ang__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ThreePointCorrelation_measure_Q_ang'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const,std::string const,std::vector< std::string > const &,int const,int const,int const,int const,bool const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const,std::string const,std::vector< std::string > const &,int const,int const,int const,int const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const,std::string const,std::vector< std::string > const &,int const,int const,int const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const,std::string const,std::vector< std::string > const &,int const,int const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const,std::string const,std::vector< std::string > const &,int const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const,std::string const,std::vector< std::string > const &)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const,std::string const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang()\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::string const,std::string const,bool const)\n"
    "    cosmobl::ThreePointCorrelation::measure_Q_ang(std::vector< std::string > const,bool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ThreePointCorrelation_write_Q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  cosmobl::ThreePointCorrelation *arg1 = (cosmobl::ThreePointCorrelation *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ThreePointCorrelation_write_Q",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cosmobl__ThreePointCorrelation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreePointCorrelation_write_Q" "', argument " "1"" of type '" "cosmobl::ThreePointCorrelation *""'"); 
  }
  arg1 = reinterpret_cast< cosmobl::ThreePointCorrelation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ThreePointCorrelation_write_Q" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->write_Q(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ThreePointCorrelation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_cosmobl__ThreePointCorrelation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Vmax_DC_distribution__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double arg11 ;
  int arg12 ;
  int arg13 ;
  bool arg14 ;
  std::string arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Vmax_DC_distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vmax_DC_distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vmax_DC_distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vmax_DC_distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Vmax_DC_distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Vmax_DC_distribution" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Vmax_DC_distribution" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Vmax_DC_distribution" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Vmax_DC_distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Vmax_DC_distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Vmax_DC_distribution" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Vmax_DC_distribution" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Vmax_DC_distribution" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Vmax_DC_distribution" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Vmax_DC_distribution" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Vmax_DC_distribution" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Vmax_DC_distribution" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  cosmobl::Vmax_DC_distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,*arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vmax_DC_distribution__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double arg11 ;
  int arg12 ;
  int arg13 ;
  bool arg14 ;
  std::string arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Vmax_DC_distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vmax_DC_distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vmax_DC_distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vmax_DC_distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Vmax_DC_distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Vmax_DC_distribution" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Vmax_DC_distribution" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Vmax_DC_distribution" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Vmax_DC_distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Vmax_DC_distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Vmax_DC_distribution" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Vmax_DC_distribution" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Vmax_DC_distribution" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Vmax_DC_distribution" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Vmax_DC_distribution" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj14, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Vmax_DC_distribution" "', argument " "15"" of type '" "std::string const""'"); 
    }
    arg15 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  cosmobl::Vmax_DC_distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,*arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vmax_DC_distribution__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double arg11 ;
  int arg12 ;
  int arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Vmax_DC_distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vmax_DC_distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vmax_DC_distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vmax_DC_distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Vmax_DC_distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Vmax_DC_distribution" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Vmax_DC_distribution" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Vmax_DC_distribution" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Vmax_DC_distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Vmax_DC_distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Vmax_DC_distribution" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Vmax_DC_distribution" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Vmax_DC_distribution" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Vmax_DC_distribution" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Vmax_DC_distribution" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  cosmobl::Vmax_DC_distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,*arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vmax_DC_distribution__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  cosmobl::Cosmology *arg10 = 0 ;
  double arg11 ;
  int arg12 ;
  int arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Vmax_DC_distribution",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vmax_DC_distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vmax_DC_distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vmax_DC_distribution" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Vmax_DC_distribution" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Vmax_DC_distribution" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Vmax_DC_distribution" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Vmax_DC_distribution" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Vmax_DC_distribution" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Vmax_DC_distribution" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Vmax_DC_distribution" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vmax_DC_distribution" "', argument " "10"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg10 = reinterpret_cast< cosmobl::Cosmology * >(argp10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Vmax_DC_distribution" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Vmax_DC_distribution" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Vmax_DC_distribution" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  cosmobl::Vmax_DC_distribution(*arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,*arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vmax_DC_distribution(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[17] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 16) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Vmax_DC_distribution__SWIG_3(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Vmax_DC_distribution__SWIG_2(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_Vmax_DC_distribution__SWIG_1(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_cosmobl__Cosmology, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_AsPtr_std_string(argv[14], (std::string**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Vmax_DC_distribution__SWIG_0(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vmax_DC_distribution'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::Vmax_DC_distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,double const,double const,double const,cosmobl::Cosmology &,double const,int const,int const,bool const,std::string const,double const)\n"
    "    cosmobl::Vmax_DC_distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,double const,double const,double const,cosmobl::Cosmology &,double const,int const,int const,bool const,std::string const)\n"
    "    cosmobl::Vmax_DC_distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,double const,double const,double const,cosmobl::Cosmology &,double const,int const,int const,bool const)\n"
    "    cosmobl::Vmax_DC_distribution(std::vector< double > &,std::vector< double > &,std::vector< double > const,std::vector< double > const,std::vector< double > const,double const,double const,double const,double const,cosmobl::Cosmology &,double const,int const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AP_shift_r(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  cosmobl::Cosmology *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:AP_shift_r",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AP_shift_r" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AP_shift_r" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AP_shift_r" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AP_shift_r" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AP_shift_r" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  result = (double)cosmobl::AP_shift_r(arg1,(cosmobl::Cosmology const &)*arg2,(cosmobl::Cosmology const &)*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AP_shift_rp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  cosmobl::Cosmology *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:AP_shift_rp",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AP_shift_rp" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AP_shift_rp" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AP_shift_rp" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AP_shift_rp" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AP_shift_rp" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  result = (double)cosmobl::AP_shift_rp(arg1,(cosmobl::Cosmology const &)*arg2,(cosmobl::Cosmology const &)*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AP_shift_pi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  cosmobl::Cosmology *arg2 = 0 ;
  cosmobl::Cosmology *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:AP_shift_pi",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AP_shift_pi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AP_shift_pi" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AP_shift_pi" "', argument " "2"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg2 = reinterpret_cast< cosmobl::Cosmology * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AP_shift_pi" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AP_shift_pi" "', argument " "3"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  result = (double)cosmobl::AP_shift_pi(arg1,(cosmobl::Cosmology const &)*arg2,(cosmobl::Cosmology const &)*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_max_separations_AP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  cosmobl::Cosmology *arg4 = 0 ;
  std::vector< cosmobl::Cosmology > *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  double *arg8 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:max_separations_AP",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "max_separations_AP" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "max_separations_AP" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "max_separations_AP" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "max_separations_AP" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "max_separations_AP" "', argument " "4"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg4 = reinterpret_cast< cosmobl::Cosmology * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_cosmobl__Cosmology_std__allocatorT_cosmobl__Cosmology_t_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "max_separations_AP" "', argument " "5"" of type '" "std::vector< cosmobl::Cosmology > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "max_separations_AP" "', argument " "5"" of type '" "std::vector< cosmobl::Cosmology > const &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< cosmobl::Cosmology > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "max_separations_AP" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "max_separations_AP" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "max_separations_AP" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "max_separations_AP" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "max_separations_AP" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "max_separations_AP" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  cosmobl::max_separations_AP(arg1,arg2,arg3,(cosmobl::Cosmology const &)*arg4,(std::vector< cosmobl::Cosmology > const &)*arg5,*arg6,*arg7,*arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_converted_xi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  cosmobl::Cosmology *arg5 = 0 ;
  cosmobl::Cosmology *arg6 = 0 ;
  bool arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:converted_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "converted_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "converted_xi" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "converted_xi" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "converted_xi" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "converted_xi" "', argument " "5"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "5"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "converted_xi" "', argument " "6"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "6"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg6 = reinterpret_cast< cosmobl::Cosmology * >(argp6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "converted_xi" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (double)cosmobl::converted_xi(arg1,arg2,arg3,arg4,(cosmobl::Cosmology const &)*arg5,(cosmobl::Cosmology const &)*arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_converted_xi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  SwigValueWrapper< std::vector< std::vector< double,std::allocator< double > > > > arg6 ;
  cosmobl::Cosmology *arg7 = 0 ;
  cosmobl::Cosmology *arg8 = 0 ;
  bool arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:converted_xi",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "converted_xi" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "converted_xi" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "converted_xi" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "converted_xi" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "converted_xi" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "converted_xi" "', argument " "6"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "6"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const""'");
    } else {
      std::vector< std::vector< double,std::allocator< double > > > * temp = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "converted_xi" "', argument " "7"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "7"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg7 = reinterpret_cast< cosmobl::Cosmology * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_cosmobl__Cosmology,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "converted_xi" "', argument " "8"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "converted_xi" "', argument " "8"" of type '" "cosmobl::Cosmology const &""'"); 
  }
  arg8 = reinterpret_cast< cosmobl::Cosmology * >(argp8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "converted_xi" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (double)cosmobl::converted_xi(arg1,arg2,arg3,arg4,arg5,arg6,(cosmobl::Cosmology const &)*arg7,(cosmobl::Cosmology const &)*arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_converted_xi(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10] = {
    0
  };
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_converted_xi__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_cosmobl__Cosmology, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_converted_xi__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'converted_xi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cosmobl::converted_xi(double const,double const,std::vector< double > const,std::vector< double > const,cosmobl::Cosmology const &,cosmobl::Cosmology const &,bool const)\n"
    "    cosmobl::converted_xi(double const,double const,double const,std::vector< double > const,std::vector< double > const,std::vector< std::vector< double,std::allocator< double > > > const,cosmobl::Cosmology const &,cosmobl::Cosmology const &,bool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_redshift_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  cosmobl::Cosmology *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:redshift_range",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "redshift_range" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "redshift_range" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "redshift_range" "', argument " "3"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "redshift_range" "', argument " "3"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg3 = reinterpret_cast< cosmobl::Cosmology * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "redshift_range" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "redshift_range" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "redshift_range" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "redshift_range" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  cosmobl::redshift_range(arg1,arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_volume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  cosmobl::Cosmology *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:volume",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "volume" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "volume" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "volume" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "volume" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "volume" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "volume" "', argument " "5"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg5 = reinterpret_cast< cosmobl::Cosmology * >(argp5);
  result = (double)cosmobl::volume(arg1,arg2,arg3,arg4,*arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_coord_zSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  std::vector< double > *arg5 = 0 ;
  std::vector< double > *arg6 = 0 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  double arg10 ;
  cosmobl::Cosmology *arg11 = 0 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  int arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:coord_zSpace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "coord_zSpace" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "1"" of type '" "std::vector< double > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "coord_zSpace" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "coord_zSpace" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "3"" of type '" "std::vector< double > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "coord_zSpace" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "4"" of type '" "std::vector< double > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "coord_zSpace" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "5"" of type '" "std::vector< double > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< double > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "coord_zSpace" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "6"" of type '" "std::vector< double > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< double > * >(argp6);
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "coord_zSpace" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "coord_zSpace" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "coord_zSpace" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "coord_zSpace" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "coord_zSpace" "', argument " "11"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "coord_zSpace" "', argument " "11"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg11 = reinterpret_cast< cosmobl::Cosmology * >(argp11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "coord_zSpace" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "coord_zSpace" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "coord_zSpace" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "coord_zSpace" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  cosmobl::coord_zSpace(*arg1,*arg2,*arg3,*arg4,*arg5,*arg6,arg7,arg8,arg9,arg10,*arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_create_mocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< double > > arg1 ;
  SwigValueWrapper< std::vector< double > > arg2 ;
  SwigValueWrapper< std::vector< double > > arg3 ;
  SwigValueWrapper< std::vector< double > > arg4 ;
  SwigValueWrapper< std::vector< double > > arg5 ;
  SwigValueWrapper< std::vector< double > > arg6 ;
  SwigValueWrapper< std::vector< double > > arg7 ;
  SwigValueWrapper< std::vector< double > > arg8 ;
  SwigValueWrapper< std::vector< double > > arg9 ;
  std::string arg10 ;
  double arg11 ;
  int arg12 ;
  double arg13 ;
  double arg14 ;
  cosmobl::Cosmology *arg15 = 0 ;
  int arg16 ;
  double arg17 ;
  int arg18 ;
  double *arg19 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:create_mocks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "create_mocks" "', argument " "1"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "1"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "create_mocks" "', argument " "2"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "2"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "create_mocks" "', argument " "3"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "3"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "create_mocks" "', argument " "4"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "4"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "create_mocks" "', argument " "5"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "5"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "create_mocks" "', argument " "6"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "6"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "create_mocks" "', argument " "7"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "7"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "create_mocks" "', argument " "8"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "8"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "create_mocks" "', argument " "9"" of type '" "std::vector< double > const""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "9"" of type '" "std::vector< double > const""'");
    } else {
      std::vector< double > * temp = reinterpret_cast< std::vector< double > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "create_mocks" "', argument " "10"" of type '" "std::string const""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "create_mocks" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "create_mocks" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "create_mocks" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "create_mocks" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_cosmobl__Cosmology,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "create_mocks" "', argument " "15"" of type '" "cosmobl::Cosmology &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "15"" of type '" "cosmobl::Cosmology &""'"); 
  }
  arg15 = reinterpret_cast< cosmobl::Cosmology * >(argp15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "create_mocks" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "create_mocks" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  ecode18 = SWIG_AsVal_int(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "create_mocks" "', argument " "18"" of type '" "int""'");
  } 
  arg18 = static_cast< int >(val18);
  res19 = SWIG_ConvertPtr(obj18, &argp19, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "create_mocks" "', argument " "19"" of type '" "double &""'"); 
  }
  if (!argp19) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create_mocks" "', argument " "19"" of type '" "double &""'"); 
  }
  arg19 = reinterpret_cast< double * >(argp19);
  cosmobl::create_mocks(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,*arg15,arg16,arg17,arg18,*arg19);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_ObjectRegion_SubBoxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:set_ObjectRegion_SubBoxes",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_ObjectRegion_SubBoxes" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_ObjectRegion_SubBoxes" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_ObjectRegion_SubBoxes" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_ObjectRegion_SubBoxes" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_ObjectRegion_SubBoxes" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "set_ObjectRegion_SubBoxes" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "set_ObjectRegion_SubBoxes" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  cosmobl::set_ObjectRegion_SubBoxes(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_ObjectRegion_mangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg1 ;
  SwigValueWrapper< std::shared_ptr< cosmobl::Catalogue > > arg2 ;
  int arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:set_ObjectRegion_mangle",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_ObjectRegion_mangle" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_ObjectRegion_mangle" "', argument " "1"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_cosmobl__Catalogue_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_ObjectRegion_mangle" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_ObjectRegion_mangle" "', argument " "2"" of type '" "std::shared_ptr< cosmobl::Catalogue >""'");
    } else {
      std::shared_ptr< cosmobl::Catalogue > * temp = reinterpret_cast< std::shared_ptr< cosmobl::Catalogue > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_ObjectRegion_mangle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "set_ObjectRegion_mangle" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "set_ObjectRegion_mangle" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  cosmobl::set_ObjectRegion_mangle(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
	 { (char *)"SHARED_PTR_DISOWN_swigconstant", SHARED_PTR_DISOWN_swigconstant, METH_VARARGS, NULL},
	 { (char *)"WarningMsg", _wrap_WarningMsg, METH_VARARGS, NULL},
	 { (char *)"ErrorMsg", _wrap_ErrorMsg, METH_VARARGS, NULL},
	 { (char *)"Beep", _wrap_Beep, METH_VARARGS, NULL},
	 { (char *)"Exit", _wrap_Exit, METH_VARARGS, NULL},
	 { (char *)"isSet", _wrap_isSet, METH_VARARGS, NULL},
	 { (char *)"ShortSwap", _wrap_ShortSwap, METH_VARARGS, NULL},
	 { (char *)"IntSwap", _wrap_IntSwap, METH_VARARGS, NULL},
	 { (char *)"LongSwap", _wrap_LongSwap, METH_VARARGS, NULL},
	 { (char *)"LongLongSwap", _wrap_LongLongSwap, METH_VARARGS, NULL},
	 { (char *)"FloatSwap", _wrap_FloatSwap, METH_VARARGS, NULL},
	 { (char *)"DoubleSwap", _wrap_DoubleSwap, METH_VARARGS, NULL},
	 { (char *)"interpolated", _wrap_interpolated, METH_VARARGS, NULL},
	 { (char *)"interpolated_2D", _wrap_interpolated_2D, METH_VARARGS, NULL},
	 { (char *)"checkIO", _wrap_checkIO, METH_VARARGS, NULL},
	 { (char *)"convert_map_gnuplot_sm", _wrap_convert_map_gnuplot_sm, METH_VARARGS, NULL},
	 { (char *)"set_EnvVar", _wrap_set_EnvVar, METH_VARARGS, NULL},
	 { (char *)"check_EnvVar", _wrap_check_EnvVar, METH_VARARGS, NULL},
	 { (char *)"used_memory", _wrap_used_memory, METH_VARARGS, NULL},
	 { (char *)"check_memory", _wrap_check_memory, METH_VARARGS, NULL},
	 { (char *)"random_numbers", _wrap_random_numbers, METH_VARARGS, NULL},
	 { (char *)"fullpath", _wrap_fullpath, METH_VARARGS, NULL},
	 { (char *)"gauleg", _wrap_gauleg, METH_VARARGS, NULL},
	 { (char *)"unique_unsorted", _wrap_unique_unsorted, METH_VARARGS, NULL},
	 { (char *)"CL_VV_set", _wrap_CL_VV_set, METH_VARARGS, NULL},
	 { (char *)"CL_VV_get", _wrap_CL_VV_get, METH_VARARGS, NULL},
	 { (char *)"new_CL", _wrap_new_CL, METH_VARARGS, NULL},
	 { (char *)"delete_CL", _wrap_delete_CL, METH_VARARGS, NULL},
	 { (char *)"CL_swigregister", CL_swigregister, METH_VARARGS, NULL},
	 { (char *)"__lt__", _wrap___lt__, METH_VARARGS, NULL},
	 { (char *)"sort_2vectors", _wrap_sort_2vectors, METH_VARARGS, NULL},
	 { (char *)"sort_3vectors", _wrap_sort_3vectors, METH_VARARGS, NULL},
	 { (char *)"sort_4vectors", _wrap_sort_4vectors, METH_VARARGS, NULL},
	 { (char *)"__mul__", _wrap___mul__, METH_VARARGS, NULL},
	 { (char *)"invert_matrix", _wrap_invert_matrix, METH_VARARGS, NULL},
	 { (char *)"invert_small_matrix", _wrap_invert_small_matrix, METH_VARARGS, NULL},
	 { (char *)"covariance_matrix", _wrap_covariance_matrix, METH_VARARGS, NULL},
	 { (char *)"read_cov", _wrap_read_cov, METH_VARARGS, NULL},
	 { (char *)"fill_distr", _wrap_fill_distr, METH_VARARGS, NULL},
	 { (char *)"find_index", _wrap_find_index, METH_VARARGS, NULL},
	 { (char *)"Moment", _wrap_Moment, METH_VARARGS, NULL},
	 { (char *)"linearfit", _wrap_linearfit, METH_VARARGS, NULL},
	 { (char *)"quadratic", _wrap_quadratic, METH_VARARGS, NULL},
	 { (char *)"cubicfit", _wrap_cubicfit, METH_VARARGS, NULL},
	 { (char *)"measure_var_function", _wrap_measure_var_function, METH_VARARGS, NULL},
	 { (char *)"quad_fit", _wrap_quad_fit, METH_VARARGS, NULL},
	 { (char *)"gaussian_fit", _wrap_gaussian_fit, METH_VARARGS, NULL},
	 { (char *)"gaussian_convolution", _wrap_gaussian_convolution, METH_VARARGS, NULL},
	 { (char *)"distribution", _wrap_distribution, METH_VARARGS, NULL},
	 { (char *)"MC_Int", _wrap_MC_Int, METH_VARARGS, NULL},
	 { (char *)"D1", _wrap_D1, METH_VARARGS, NULL},
	 { (char *)"D2", _wrap_D2, METH_VARARGS, NULL},
	 { (char *)"Deriv", _wrap_Deriv, METH_VARARGS, NULL},
	 { (char *)"bin_function", _wrap_bin_function, METH_VARARGS, NULL},
	 { (char *)"bin_function_2D", _wrap_bin_function_2D, METH_VARARGS, NULL},
	 { (char *)"func_grid_lin", _wrap_func_grid_lin, METH_VARARGS, NULL},
	 { (char *)"func_grid_loglin", _wrap_func_grid_loglin, METH_VARARGS, NULL},
	 { (char *)"func_grid_log", _wrap_func_grid_log, METH_VARARGS, NULL},
	 { (char *)"func_grid_lin_2D", _wrap_func_grid_lin_2D, METH_VARARGS, NULL},
	 { (char *)"func_grid_loglin_2D", _wrap_func_grid_loglin_2D, METH_VARARGS, NULL},
	 { (char *)"func_grid_log_2D", _wrap_func_grid_log_2D, METH_VARARGS, NULL},
	 { (char *)"convolution", _wrap_convolution, METH_VARARGS, NULL},
	 { (char *)"polar_coord", _wrap_polar_coord, METH_VARARGS, NULL},
	 { (char *)"cartesian_coord", _wrap_cartesian_coord, METH_VARARGS, NULL},
	 { (char *)"eq2sdss", _wrap_eq2sdss, METH_VARARGS, NULL},
	 { (char *)"sdss2eq", _wrap_sdss2eq, METH_VARARGS, NULL},
	 { (char *)"sdss_stripe", _wrap_sdss_stripe, METH_VARARGS, NULL},
	 { (char *)"xi_from_Pk", _wrap_xi_from_Pk, METH_VARARGS, NULL},
	 { (char *)"Pk_from_xi", _wrap_Pk_from_xi, METH_VARARGS, NULL},
	 { (char *)"func_xi_GSL", _wrap_func_xi_GSL, METH_VARARGS, NULL},
	 { (char *)"func_SSM_GSL", _wrap_func_SSM_GSL, METH_VARARGS, NULL},
	 { (char *)"wp", _wrap_wp, METH_VARARGS, NULL},
	 { (char *)"sigmaR", _wrap_sigmaR, METH_VARARGS, NULL},
	 { (char *)"xi_projected_powerlaw", _wrap_xi_projected_powerlaw, METH_VARARGS, NULL},
	 { (char *)"xi_ratio", _wrap_xi_ratio, METH_VARARGS, NULL},
	 { (char *)"error_xi_ratio", _wrap_error_xi_ratio, METH_VARARGS, NULL},
	 { (char *)"barred_xi_direct", _wrap_barred_xi_direct, METH_VARARGS, NULL},
	 { (char *)"barred_xi__direct", _wrap_barred_xi__direct, METH_VARARGS, NULL},
	 { (char *)"barred_xi_", _wrap_barred_xi_, METH_VARARGS, NULL},
	 { (char *)"barred_xi__", _wrap_barred_xi__, METH_VARARGS, NULL},
	 { (char *)"multipole_xi0", _wrap_multipole_xi0, METH_VARARGS, NULL},
	 { (char *)"multipole_xi2", _wrap_multipole_xi2, METH_VARARGS, NULL},
	 { (char *)"multipole_xi4", _wrap_multipole_xi4, METH_VARARGS, NULL},
	 { (char *)"error_multipole_xi0", _wrap_error_multipole_xi0, METH_VARARGS, NULL},
	 { (char *)"error_multipole_xi2", _wrap_error_multipole_xi2, METH_VARARGS, NULL},
	 { (char *)"error_multipole_xi4", _wrap_error_multipole_xi4, METH_VARARGS, NULL},
	 { (char *)"multipoles", _wrap_multipoles, METH_VARARGS, NULL},
	 { (char *)"multipole_xi0_model", _wrap_multipole_xi0_model, METH_VARARGS, NULL},
	 { (char *)"multipole_xi2_model", _wrap_multipole_xi2_model, METH_VARARGS, NULL},
	 { (char *)"multipole_xi4_model", _wrap_multipole_xi4_model, METH_VARARGS, NULL},
	 { (char *)"xi2D_lin_model", _wrap_xi2D_lin_model, METH_VARARGS, NULL},
	 { (char *)"xi2D_model", _wrap_xi2D_model, METH_VARARGS, NULL},
	 { (char *)"f_v", _wrap_f_v, METH_VARARGS, NULL},
	 { (char *)"f_star", _wrap_f_star, METH_VARARGS, NULL},
	 { (char *)"b_nl", _wrap_b_nl, METH_VARARGS, NULL},
	 { (char *)"relative_error_beta", _wrap_relative_error_beta, METH_VARARGS, NULL},
	 { (char *)"STR_grid__xx_set", _wrap_STR_grid__xx_set, METH_VARARGS, NULL},
	 { (char *)"STR_grid__xx_get", _wrap_STR_grid__xx_get, METH_VARARGS, NULL},
	 { (char *)"STR_grid__yy_set", _wrap_STR_grid__yy_set, METH_VARARGS, NULL},
	 { (char *)"STR_grid__yy_get", _wrap_STR_grid__yy_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_grid", _wrap_new_STR_grid, METH_VARARGS, NULL},
	 { (char *)"delete_STR_grid", _wrap_delete_STR_grid, METH_VARARGS, NULL},
	 { (char *)"STR_grid_swigregister", STR_grid_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_grid_2D__xx1_set", _wrap_STR_grid_2D__xx1_set, METH_VARARGS, NULL},
	 { (char *)"STR_grid_2D__xx1_get", _wrap_STR_grid_2D__xx1_get, METH_VARARGS, NULL},
	 { (char *)"STR_grid_2D__xx2_set", _wrap_STR_grid_2D__xx2_set, METH_VARARGS, NULL},
	 { (char *)"STR_grid_2D__xx2_get", _wrap_STR_grid_2D__xx2_get, METH_VARARGS, NULL},
	 { (char *)"STR_grid_2D__yy_set", _wrap_STR_grid_2D__yy_set, METH_VARARGS, NULL},
	 { (char *)"STR_grid_2D__yy_get", _wrap_STR_grid_2D__yy_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_grid_2D", _wrap_new_STR_grid_2D, METH_VARARGS, NULL},
	 { (char *)"delete_STR_grid_2D", _wrap_delete_STR_grid_2D, METH_VARARGS, NULL},
	 { (char *)"STR_grid_2D_swigregister", STR_grid_2D_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_xi0_model_bias_sigma8_set", _wrap_STR_xi0_model_bias_sigma8_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0_model_bias_sigma8_get", _wrap_STR_xi0_model_bias_sigma8_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0_model_sigma8z_set", _wrap_STR_xi0_model_sigma8z_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0_model_sigma8z_get", _wrap_STR_xi0_model_sigma8z_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0_model_xi_DM_set", _wrap_STR_xi0_model_xi_DM_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0_model_xi_DM_get", _wrap_STR_xi0_model_xi_DM_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_xi0_model", _wrap_new_STR_xi0_model, METH_VARARGS, NULL},
	 { (char *)"delete_STR_xi0_model", _wrap_delete_STR_xi0_model, METH_VARARGS, NULL},
	 { (char *)"STR_xi0_model_swigregister", STR_xi0_model_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_rp_set", _wrap_STR_xi2D_model_rp_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_rp_get", _wrap_STR_xi2D_model_rp_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_pi_set", _wrap_STR_xi2D_model_pi_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_pi_get", _wrap_STR_xi2D_model_pi_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_xi_real_set", _wrap_STR_xi2D_model_xi_real_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_xi_real_get", _wrap_STR_xi2D_model_xi_real_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_xi__set", _wrap_STR_xi2D_model_xi__set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_xi__get", _wrap_STR_xi2D_model_xi__get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_xi___set", _wrap_STR_xi2D_model_xi___set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_xi___get", _wrap_STR_xi2D_model_xi___get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_P2_set", _wrap_STR_xi2D_model_P2_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_P2_get", _wrap_STR_xi2D_model_P2_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_P4_set", _wrap_STR_xi2D_model_P4_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_P4_get", _wrap_STR_xi2D_model_P4_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_vel_set", _wrap_STR_xi2D_model_vel_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_vel_get", _wrap_STR_xi2D_model_vel_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_lim_index_fit_set", _wrap_STR_xi2D_model_lim_index_fit_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_lim_index_fit_get", _wrap_STR_xi2D_model_lim_index_fit_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_type_set", _wrap_STR_xi2D_model_type_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_type_get", _wrap_STR_xi2D_model_type_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_step_v_set", _wrap_STR_xi2D_model_step_v_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_step_v_get", _wrap_STR_xi2D_model_step_v_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_FV_set", _wrap_STR_xi2D_model_FV_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_FV_get", _wrap_STR_xi2D_model_FV_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_dim_set", _wrap_STR_xi2D_model_dim_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_dim_get", _wrap_STR_xi2D_model_dim_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_delta_v_set", _wrap_STR_xi2D_model_delta_v_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_delta_v_get", _wrap_STR_xi2D_model_delta_v_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_bias_nl_set", _wrap_STR_xi2D_model_bias_nl_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_bias_nl_get", _wrap_STR_xi2D_model_bias_nl_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_xi2D_model", _wrap_new_STR_xi2D_model, METH_VARARGS, NULL},
	 { (char *)"delete_STR_xi2D_model", _wrap_delete_STR_xi2D_model, METH_VARARGS, NULL},
	 { (char *)"STR_xi2D_model_swigregister", STR_xi2D_model_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_xi_rr_set", _wrap_STR_xi_rr_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_rr_get", _wrap_STR_xi_rr_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_aa_set", _wrap_STR_xi_aa_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_aa_get", _wrap_STR_xi_aa_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_lgkk_set", _wrap_STR_xi_lgkk_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_lgkk_get", _wrap_STR_xi_lgkk_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_lgPk_set", _wrap_STR_xi_lgPk_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_lgPk_get", _wrap_STR_xi_lgPk_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_xi", _wrap_new_STR_xi, METH_VARARGS, NULL},
	 { (char *)"delete_STR_xi", _wrap_delete_STR_xi, METH_VARARGS, NULL},
	 { (char *)"STR_xi_swigregister", STR_xi_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_unit_set", _wrap_STR_SSM_unit_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_unit_get", _wrap_STR_SSM_unit_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_hh_set", _wrap_STR_SSM_hh_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_hh_get", _wrap_STR_SSM_hh_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_mass_set", _wrap_STR_SSM_mass_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_mass_get", _wrap_STR_SSM_mass_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_rho_set", _wrap_STR_SSM_rho_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_rho_get", _wrap_STR_SSM_rho_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_n_spec_set", _wrap_STR_SSM_n_spec_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_n_spec_get", _wrap_STR_SSM_n_spec_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_lgkk_set", _wrap_STR_SSM_lgkk_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_lgkk_get", _wrap_STR_SSM_lgkk_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_lgPk_set", _wrap_STR_SSM_lgPk_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_lgPk_get", _wrap_STR_SSM_lgPk_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_SSM", _wrap_new_STR_SSM, METH_VARARGS, NULL},
	 { (char *)"delete_STR_SSM", _wrap_delete_STR_SSM, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_swigregister", STR_SSM_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Cosmology", _wrap_new_Cosmology, METH_VARARGS, NULL},
	 { (char *)"delete_Cosmology", _wrap_delete_Cosmology, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Omega_matter", _wrap_Cosmology_Omega_matter, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Omega_baryon", _wrap_Cosmology_Omega_baryon, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Omega_neutrinos", _wrap_Cosmology_Omega_neutrinos, METH_VARARGS, NULL},
	 { (char *)"Cosmology_massless_neutrinos", _wrap_Cosmology_massless_neutrinos, METH_VARARGS, NULL},
	 { (char *)"Cosmology_massive_neutrinos", _wrap_Cosmology_massive_neutrinos, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Omega_DE", _wrap_Cosmology_Omega_DE, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Omega_radiation", _wrap_Cosmology_Omega_radiation, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Omega_k", _wrap_Cosmology_Omega_k, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Omega_CDM", _wrap_Cosmology_Omega_CDM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_H0", _wrap_Cosmology_H0, METH_VARARGS, NULL},
	 { (char *)"Cosmology_hh", _wrap_Cosmology_hh, METH_VARARGS, NULL},
	 { (char *)"Cosmology_t_H", _wrap_Cosmology_t_H, METH_VARARGS, NULL},
	 { (char *)"Cosmology_D_H", _wrap_Cosmology_D_H, METH_VARARGS, NULL},
	 { (char *)"Cosmology_sigma8", _wrap_Cosmology_sigma8, METH_VARARGS, NULL},
	 { (char *)"Cosmology_scalar_amp", _wrap_Cosmology_scalar_amp, METH_VARARGS, NULL},
	 { (char *)"Cosmology_n_spec", _wrap_Cosmology_n_spec, METH_VARARGS, NULL},
	 { (char *)"Cosmology_w0", _wrap_Cosmology_w0, METH_VARARGS, NULL},
	 { (char *)"Cosmology_wa", _wrap_Cosmology_wa, METH_VARARGS, NULL},
	 { (char *)"Cosmology_RhoZero", _wrap_Cosmology_RhoZero, METH_VARARGS, NULL},
	 { (char *)"Cosmology_fNL", _wrap_Cosmology_fNL, METH_VARARGS, NULL},
	 { (char *)"Cosmology_type_NG", _wrap_Cosmology_type_NG, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Pk0_EH", _wrap_Cosmology_Pk0_EH, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Pk0_CAMB", _wrap_Cosmology_Pk0_CAMB, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Pk0_MPTbreeze", _wrap_Cosmology_Pk0_MPTbreeze, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Pk0_CLASS", _wrap_Cosmology_Pk0_CLASS, METH_VARARGS, NULL},
	 { (char *)"Cosmology_model", _wrap_Cosmology_model, METH_VARARGS, NULL},
	 { (char *)"Cosmology_unit", _wrap_Cosmology_unit, METH_VARARGS, NULL},
	 { (char *)"Cosmology_print_parameters", _wrap_Cosmology_print_parameters, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_Omega", _wrap_Cosmology_set_Omega, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_OmegaB", _wrap_Cosmology_set_OmegaB, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_OmegaM", _wrap_Cosmology_set_OmegaM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_OmegaDE", _wrap_Cosmology_set_OmegaDE, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_OmegaNu", _wrap_Cosmology_set_OmegaNu, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_H0", _wrap_Cosmology_set_H0, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_sigma8", _wrap_Cosmology_set_sigma8, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_scalar_amp", _wrap_Cosmology_set_scalar_amp, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_w0", _wrap_Cosmology_set_w0, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_wa", _wrap_Cosmology_set_wa, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_RhoZero", _wrap_Cosmology_set_RhoZero, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_fNL", _wrap_Cosmology_set_fNL, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_type_NG", _wrap_Cosmology_set_type_NG, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_model", _wrap_Cosmology_set_model, METH_VARARGS, NULL},
	 { (char *)"Cosmology_set_unit", _wrap_Cosmology_set_unit, METH_VARARGS, NULL},
	 { (char *)"Cosmology_OmegaM", _wrap_Cosmology_OmegaM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_OmegaDE", _wrap_Cosmology_OmegaDE, METH_VARARGS, NULL},
	 { (char *)"Cosmology_OmegaR", _wrap_Cosmology_OmegaR, METH_VARARGS, NULL},
	 { (char *)"Cosmology_OmegaK", _wrap_Cosmology_OmegaK, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Omega", _wrap_Cosmology_Omega, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Rho", _wrap_Cosmology_Rho, METH_VARARGS, NULL},
	 { (char *)"Cosmology_DeltaR", _wrap_Cosmology_DeltaR, METH_VARARGS, NULL},
	 { (char *)"Cosmology_w_CPL", _wrap_Cosmology_w_CPL, METH_VARARGS, NULL},
	 { (char *)"Cosmology_f_DE", _wrap_Cosmology_f_DE, METH_VARARGS, NULL},
	 { (char *)"Cosmology_EE", _wrap_Cosmology_EE, METH_VARARGS, NULL},
	 { (char *)"Cosmology_HH", _wrap_Cosmology_HH, METH_VARARGS, NULL},
	 { (char *)"Cosmology_gg", _wrap_Cosmology_gg, METH_VARARGS, NULL},
	 { (char *)"Cosmology_DD", _wrap_Cosmology_DD, METH_VARARGS, NULL},
	 { (char *)"Cosmology_lookback_time", _wrap_Cosmology_lookback_time, METH_VARARGS, NULL},
	 { (char *)"Cosmology_cosmic_time", _wrap_Cosmology_cosmic_time, METH_VARARGS, NULL},
	 { (char *)"Cosmology_EE2", _wrap_Cosmology_EE2, METH_VARARGS, NULL},
	 { (char *)"Cosmology_qq", _wrap_Cosmology_qq, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Hdot", _wrap_Cosmology_Hdot, METH_VARARGS, NULL},
	 { (char *)"Cosmology_z_acc", _wrap_Cosmology_z_acc, METH_VARARGS, NULL},
	 { (char *)"Cosmology_z_eq", _wrap_Cosmology_z_eq, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Mag_Volume_limited", _wrap_Cosmology_Mag_Volume_limited, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Lum_bol", _wrap_Cosmology_Lum_bol, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Redshift_LCDM", _wrap_Cosmology_Redshift_LCDM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Redshift", _wrap_Cosmology_Redshift, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Redshift_time", _wrap_Cosmology_Redshift_time, METH_VARARGS, NULL},
	 { (char *)"Cosmology_deltac", _wrap_Cosmology_deltac, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Deltavir", _wrap_Cosmology_Deltavir, METH_VARARGS, NULL},
	 { (char *)"Cosmology_D_C", _wrap_Cosmology_D_C, METH_VARARGS, NULL},
	 { (char *)"Cosmology_D_C_LCDM", _wrap_Cosmology_D_C_LCDM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_D_C_table", _wrap_Cosmology_D_C_table, METH_VARARGS, NULL},
	 { (char *)"Cosmology_D_M", _wrap_Cosmology_D_M, METH_VARARGS, NULL},
	 { (char *)"Cosmology_D_A", _wrap_Cosmology_D_A, METH_VARARGS, NULL},
	 { (char *)"Cosmology_D_L", _wrap_Cosmology_D_L, METH_VARARGS, NULL},
	 { (char *)"Cosmology_D_V", _wrap_Cosmology_D_V, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Distance", _wrap_Cosmology_Distance, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Volume", _wrap_Cosmology_Volume, METH_VARARGS, NULL},
	 { (char *)"Cosmology_max_redshift", _wrap_Cosmology_max_redshift, METH_VARARGS, NULL},
	 { (char *)"Cosmology_dV_dZdOmega", _wrap_Cosmology_dV_dZdOmega, METH_VARARGS, NULL},
	 { (char *)"Cosmology_mass_function_fast", _wrap_Cosmology_mass_function_fast, METH_VARARGS, NULL},
	 { (char *)"Cosmology_mass_function", _wrap_Cosmology_mass_function, METH_VARARGS, NULL},
	 { (char *)"Cosmology_n_haloes", _wrap_Cosmology_n_haloes, METH_VARARGS, NULL},
	 { (char *)"Cosmology_MhaloMin", _wrap_Cosmology_MhaloMin, METH_VARARGS, NULL},
	 { (char *)"Cosmology_pw", _wrap_Cosmology_pw, METH_VARARGS, NULL},
	 { (char *)"Cosmology_pz", _wrap_Cosmology_pz, METH_VARARGS, NULL},
	 { (char *)"Cosmology_cumPw", _wrap_Cosmology_cumPw, METH_VARARGS, NULL},
	 { (char *)"Cosmology_medianwf", _wrap_Cosmology_medianwf, METH_VARARGS, NULL},
	 { (char *)"Cosmology_medianzf", _wrap_Cosmology_medianzf, METH_VARARGS, NULL},
	 { (char *)"Cosmology_wf", _wrap_Cosmology_wf, METH_VARARGS, NULL},
	 { (char *)"Cosmology_unevolved_mass_function", _wrap_Cosmology_unevolved_mass_function, METH_VARARGS, NULL},
	 { (char *)"Cosmology_concentration", _wrap_Cosmology_concentration, METH_VARARGS, NULL},
	 { (char *)"Cosmology_As", _wrap_Cosmology_As, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Pk_UnNorm", _wrap_Cosmology_Pk_UnNorm, METH_VARARGS, NULL},
	 { (char *)"Cosmology_run_CAMB", _wrap_Cosmology_run_CAMB, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Table_PkCodes", _wrap_Cosmology_Table_PkCodes, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Pk_0", _wrap_Cosmology_Pk_0, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Pk", _wrap_Cosmology_Pk, METH_VARARGS, NULL},
	 { (char *)"Cosmology_SSR", _wrap_Cosmology_SSR, METH_VARARGS, NULL},
	 { (char *)"Cosmology_SSR_norm", _wrap_Cosmology_SSR_norm, METH_VARARGS, NULL},
	 { (char *)"Cosmology_SSM", _wrap_Cosmology_SSM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_SSM_norm", _wrap_Cosmology_SSM_norm, METH_VARARGS, NULL},
	 { (char *)"Cosmology_dnSR", _wrap_Cosmology_dnSR, METH_VARARGS, NULL},
	 { (char *)"Cosmology_dnSM", _wrap_Cosmology_dnSM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_xi_DM", _wrap_Cosmology_xi_DM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_xi_DM_DeWiggle", _wrap_Cosmology_xi_DM_DeWiggle, METH_VARARGS, NULL},
	 { (char *)"Cosmology_get_xi", _wrap_Cosmology_get_xi, METH_VARARGS, NULL},
	 { (char *)"Cosmology_get_barred_xi", _wrap_Cosmology_get_barred_xi, METH_VARARGS, NULL},
	 { (char *)"Cosmology_wp_DM", _wrap_Cosmology_wp_DM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_k_star", _wrap_Cosmology_k_star, METH_VARARGS, NULL},
	 { (char *)"Cosmology_sigmaR_DM", _wrap_Cosmology_sigmaR_DM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_sigma8_Pk", _wrap_Cosmology_sigma8_Pk, METH_VARARGS, NULL},
	 { (char *)"Cosmology_bias_halo", _wrap_Cosmology_bias_halo, METH_VARARGS, NULL},
	 { (char *)"Cosmology_bias_eff", _wrap_Cosmology_bias_eff, METH_VARARGS, NULL},
	 { (char *)"Cosmology_linear_growth_rate", _wrap_Cosmology_linear_growth_rate, METH_VARARGS, NULL},
	 { (char *)"Cosmology_fsigma8", _wrap_Cosmology_fsigma8, METH_VARARGS, NULL},
	 { (char *)"Cosmology_beta", _wrap_Cosmology_beta, METH_VARARGS, NULL},
	 { (char *)"Cosmology_error_beta", _wrap_Cosmology_error_beta, METH_VARARGS, NULL},
	 { (char *)"Cosmology_error_beta_measured", _wrap_Cosmology_error_beta_measured, METH_VARARGS, NULL},
	 { (char *)"Cosmology_quadrupole", _wrap_Cosmology_quadrupole, METH_VARARGS, NULL},
	 { (char *)"Cosmology_square_bulk_flow", _wrap_Cosmology_square_bulk_flow, METH_VARARGS, NULL},
	 { (char *)"Cosmology_square_bulk_flow_Table", _wrap_Cosmology_square_bulk_flow_Table, METH_VARARGS, NULL},
	 { (char *)"Cosmology_square_velocity_dispersion", _wrap_Cosmology_square_velocity_dispersion, METH_VARARGS, NULL},
	 { (char *)"Cosmology_CMN", _wrap_Cosmology_CMN, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Sn_PT", _wrap_Cosmology_Sn_PT, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Sigman_PT", _wrap_Cosmology_Sigman_PT, METH_VARARGS, NULL},
	 { (char *)"Cosmology_xi0_Kaiser", _wrap_Cosmology_xi0_Kaiser, METH_VARARGS, NULL},
	 { (char *)"Cosmology_xi2D_DispersionModel", _wrap_Cosmology_xi2D_DispersionModel, METH_VARARGS, NULL},
	 { (char *)"Cosmology_xi_star", _wrap_Cosmology_xi_star, METH_VARARGS, NULL},
	 { (char *)"Cosmology_xisnl_gnw", _wrap_Cosmology_xisnl_gnw, METH_VARARGS, NULL},
	 { (char *)"Cosmology_xis_gBAO", _wrap_Cosmology_xis_gBAO, METH_VARARGS, NULL},
	 { (char *)"Cosmology_xi2D_CW", _wrap_Cosmology_xi2D_CW, METH_VARARGS, NULL},
	 { (char *)"Cosmology_rs", _wrap_Cosmology_rs, METH_VARARGS, NULL},
	 { (char *)"Cosmology_rs_EH", _wrap_Cosmology_rs_EH, METH_VARARGS, NULL},
	 { (char *)"Cosmology_rs_CAMB", _wrap_Cosmology_rs_CAMB, METH_VARARGS, NULL},
	 { (char *)"Cosmology_ys", _wrap_Cosmology_ys, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Az", _wrap_Cosmology_Az, METH_VARARGS, NULL},
	 { (char *)"Cosmology_Am", _wrap_Cosmology_Am, METH_VARARGS, NULL},
	 { (char *)"Cosmology_potential_spectral_amplitude", _wrap_Cosmology_potential_spectral_amplitude, METH_VARARGS, NULL},
	 { (char *)"Cosmology_bispectrum", _wrap_Cosmology_bispectrum, METH_VARARGS, NULL},
	 { (char *)"Cosmology_mrk", _wrap_Cosmology_mrk, METH_VARARGS, NULL},
	 { (char *)"Cosmology_frk", _wrap_Cosmology_frk, METH_VARARGS, NULL},
	 { (char *)"Cosmology_bias_kernel", _wrap_Cosmology_bias_kernel, METH_VARARGS, NULL},
	 { (char *)"Cosmology_frk_test", _wrap_Cosmology_frk_test, METH_VARARGS, NULL},
	 { (char *)"Cosmology_bias_correction", _wrap_Cosmology_bias_correction, METH_VARARGS, NULL},
	 { (char *)"Cosmology_skewness", _wrap_Cosmology_skewness, METH_VARARGS, NULL},
	 { (char *)"Cosmology_dskewnessdM", _wrap_Cosmology_dskewnessdM, METH_VARARGS, NULL},
	 { (char *)"Cosmology_MF_correction", _wrap_Cosmology_MF_correction, METH_VARARGS, NULL},
	 { (char *)"Cosmology_VolS", _wrap_Cosmology_VolS, METH_VARARGS, NULL},
	 { (char *)"Cosmology_deltav", _wrap_Cosmology_deltav, METH_VARARGS, NULL},
	 { (char *)"Cosmology_r_rL", _wrap_Cosmology_r_rL, METH_VARARGS, NULL},
	 { (char *)"Cosmology_f_nu", _wrap_Cosmology_f_nu, METH_VARARGS, NULL},
	 { (char *)"Cosmology_size_function", _wrap_Cosmology_size_function, METH_VARARGS, NULL},
	 { (char *)"Cosmology_swigregister", Cosmology_swigregister, METH_VARARGS, NULL},
	 { (char *)"GSL_bias_kernel_wrapper", _wrap_GSL_bias_kernel_wrapper, METH_VARARGS, NULL},
	 { (char *)"func_xi_EH_GSL", _wrap_func_xi_EH_GSL, METH_VARARGS, NULL},
	 { (char *)"func_SSM_EH_GSL", _wrap_func_SSM_EH_GSL, METH_VARARGS, NULL},
	 { (char *)"bias_kernel2", _wrap_bias_kernel2, METH_VARARGS, NULL},
	 { (char *)"skewness_kernel", _wrap_skewness_kernel, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_kt_set", _wrap_GSL_f_pars_kt_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_kt_get", _wrap_GSL_f_pars_kt_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_mass_set", _wrap_GSL_f_pars_mass_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_mass_get", _wrap_GSL_f_pars_mass_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_method_Pk_set", _wrap_GSL_f_pars_method_Pk_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_method_Pk_get", _wrap_GSL_f_pars_method_Pk_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_output_root_set", _wrap_GSL_f_pars_output_root_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_output_root_get", _wrap_GSL_f_pars_output_root_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_norm_set", _wrap_GSL_f_pars_norm_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_norm_get", _wrap_GSL_f_pars_norm_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_k_min_set", _wrap_GSL_f_pars_k_min_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_k_min_get", _wrap_GSL_f_pars_k_min_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_k_max_set", _wrap_GSL_f_pars_k_max_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_k_max_get", _wrap_GSL_f_pars_k_max_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_GSL_set", _wrap_GSL_f_pars_GSL_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_GSL_get", _wrap_GSL_f_pars_GSL_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_prec_set", _wrap_GSL_f_pars_prec_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_prec_get", _wrap_GSL_f_pars_prec_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_file_par_set", _wrap_GSL_f_pars_file_par_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_file_par_get", _wrap_GSL_f_pars_file_par_get, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_pt_Cosmology_set", _wrap_GSL_f_pars_pt_Cosmology_set, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_pt_Cosmology_get", _wrap_GSL_f_pars_pt_Cosmology_get, METH_VARARGS, NULL},
	 { (char *)"new_GSL_f_pars", _wrap_new_GSL_f_pars, METH_VARARGS, NULL},
	 { (char *)"delete_GSL_f_pars", _wrap_delete_GSL_f_pars, METH_VARARGS, NULL},
	 { (char *)"GSL_f_pars_swigregister", GSL_f_pars_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_matter_set", _wrap_STR_xi_EH_Omega_matter_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_matter_get", _wrap_STR_xi_EH_Omega_matter_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_baryon_set", _wrap_STR_xi_EH_Omega_baryon_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_baryon_get", _wrap_STR_xi_EH_Omega_baryon_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_neutrinos_set", _wrap_STR_xi_EH_Omega_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_neutrinos_get", _wrap_STR_xi_EH_Omega_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_massless_neutrinos_set", _wrap_STR_xi_EH_massless_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_massless_neutrinos_get", _wrap_STR_xi_EH_massless_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_massive_neutrinos_set", _wrap_STR_xi_EH_massive_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_massive_neutrinos_get", _wrap_STR_xi_EH_massive_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_DE_set", _wrap_STR_xi_EH_Omega_DE_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_DE_get", _wrap_STR_xi_EH_Omega_DE_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_radiation_set", _wrap_STR_xi_EH_Omega_radiation_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_Omega_radiation_get", _wrap_STR_xi_EH_Omega_radiation_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_hh_set", _wrap_STR_xi_EH_hh_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_hh_get", _wrap_STR_xi_EH_hh_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_scalar_amp_set", _wrap_STR_xi_EH_scalar_amp_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_scalar_amp_get", _wrap_STR_xi_EH_scalar_amp_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_n_spec_set", _wrap_STR_xi_EH_n_spec_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_n_spec_get", _wrap_STR_xi_EH_n_spec_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_w0_set", _wrap_STR_xi_EH_w0_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_w0_get", _wrap_STR_xi_EH_w0_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_wa_set", _wrap_STR_xi_EH_wa_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_wa_get", _wrap_STR_xi_EH_wa_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_fNL_set", _wrap_STR_xi_EH_fNL_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_fNL_get", _wrap_STR_xi_EH_fNL_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_type_NG_set", _wrap_STR_xi_EH_type_NG_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_type_NG_get", _wrap_STR_xi_EH_type_NG_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_model_set", _wrap_STR_xi_EH_model_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_model_get", _wrap_STR_xi_EH_model_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_unit_set", _wrap_STR_xi_EH_unit_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_unit_get", _wrap_STR_xi_EH_unit_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_method_Pk_set", _wrap_STR_xi_EH_method_Pk_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_method_Pk_get", _wrap_STR_xi_EH_method_Pk_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_rr_set", _wrap_STR_xi_EH_rr_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_rr_get", _wrap_STR_xi_EH_rr_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_redshift_set", _wrap_STR_xi_EH_redshift_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_redshift_get", _wrap_STR_xi_EH_redshift_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_aa_set", _wrap_STR_xi_EH_aa_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_aa_get", _wrap_STR_xi_EH_aa_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_xi_EH", _wrap_new_STR_xi_EH, METH_VARARGS, NULL},
	 { (char *)"delete_STR_xi_EH", _wrap_delete_STR_xi_EH, METH_VARARGS, NULL},
	 { (char *)"STR_xi_EH_swigregister", STR_xi_EH_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_matter_set", _wrap_STR_SSM_EH_Omega_matter_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_matter_get", _wrap_STR_SSM_EH_Omega_matter_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_baryon_set", _wrap_STR_SSM_EH_Omega_baryon_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_baryon_get", _wrap_STR_SSM_EH_Omega_baryon_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_neutrinos_set", _wrap_STR_SSM_EH_Omega_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_neutrinos_get", _wrap_STR_SSM_EH_Omega_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_massless_neutrinos_set", _wrap_STR_SSM_EH_massless_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_massless_neutrinos_get", _wrap_STR_SSM_EH_massless_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_massive_neutrinos_set", _wrap_STR_SSM_EH_massive_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_massive_neutrinos_get", _wrap_STR_SSM_EH_massive_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_DE_set", _wrap_STR_SSM_EH_Omega_DE_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_DE_get", _wrap_STR_SSM_EH_Omega_DE_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_radiation_set", _wrap_STR_SSM_EH_Omega_radiation_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_Omega_radiation_get", _wrap_STR_SSM_EH_Omega_radiation_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_hh_set", _wrap_STR_SSM_EH_hh_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_hh_get", _wrap_STR_SSM_EH_hh_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_scalar_amp_set", _wrap_STR_SSM_EH_scalar_amp_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_scalar_amp_get", _wrap_STR_SSM_EH_scalar_amp_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_n_spec_set", _wrap_STR_SSM_EH_n_spec_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_n_spec_get", _wrap_STR_SSM_EH_n_spec_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_w0_set", _wrap_STR_SSM_EH_w0_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_w0_get", _wrap_STR_SSM_EH_w0_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_wa_set", _wrap_STR_SSM_EH_wa_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_wa_get", _wrap_STR_SSM_EH_wa_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_fNL_set", _wrap_STR_SSM_EH_fNL_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_fNL_get", _wrap_STR_SSM_EH_fNL_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_type_NG_set", _wrap_STR_SSM_EH_type_NG_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_type_NG_get", _wrap_STR_SSM_EH_type_NG_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_model_set", _wrap_STR_SSM_EH_model_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_model_get", _wrap_STR_SSM_EH_model_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_unit_set", _wrap_STR_SSM_EH_unit_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_unit_get", _wrap_STR_SSM_EH_unit_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_method_Pk_set", _wrap_STR_SSM_EH_method_Pk_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_method_Pk_get", _wrap_STR_SSM_EH_method_Pk_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_redshift_set", _wrap_STR_SSM_EH_redshift_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_redshift_get", _wrap_STR_SSM_EH_redshift_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_mass_set", _wrap_STR_SSM_EH_mass_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_mass_get", _wrap_STR_SSM_EH_mass_get, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_rho_set", _wrap_STR_SSM_EH_rho_set, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_rho_get", _wrap_STR_SSM_EH_rho_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_SSM_EH", _wrap_new_STR_SSM_EH, METH_VARARGS, NULL},
	 { (char *)"delete_STR_SSM_EH", _wrap_delete_STR_SSM_EH, METH_VARARGS, NULL},
	 { (char *)"STR_SSM_EH_swigregister", STR_SSM_EH_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_matter_set", _wrap_STR_NG_Omega_matter_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_matter_get", _wrap_STR_NG_Omega_matter_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_baryon_set", _wrap_STR_NG_Omega_baryon_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_baryon_get", _wrap_STR_NG_Omega_baryon_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_neutrinos_set", _wrap_STR_NG_Omega_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_neutrinos_get", _wrap_STR_NG_Omega_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_massless_neutrinos_set", _wrap_STR_NG_massless_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_massless_neutrinos_get", _wrap_STR_NG_massless_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_massive_neutrinos_set", _wrap_STR_NG_massive_neutrinos_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_massive_neutrinos_get", _wrap_STR_NG_massive_neutrinos_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_DE_set", _wrap_STR_NG_Omega_DE_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_DE_get", _wrap_STR_NG_Omega_DE_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_radiation_set", _wrap_STR_NG_Omega_radiation_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_Omega_radiation_get", _wrap_STR_NG_Omega_radiation_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_hh_set", _wrap_STR_NG_hh_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_hh_get", _wrap_STR_NG_hh_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_scalar_amp_set", _wrap_STR_NG_scalar_amp_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_scalar_amp_get", _wrap_STR_NG_scalar_amp_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_n_spec_set", _wrap_STR_NG_n_spec_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_n_spec_get", _wrap_STR_NG_n_spec_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_w0_set", _wrap_STR_NG_w0_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_w0_get", _wrap_STR_NG_w0_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_wa_set", _wrap_STR_NG_wa_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_wa_get", _wrap_STR_NG_wa_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_fNL_set", _wrap_STR_NG_fNL_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_fNL_get", _wrap_STR_NG_fNL_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_type_NG_set", _wrap_STR_NG_type_NG_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_type_NG_get", _wrap_STR_NG_type_NG_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_model_set", _wrap_STR_NG_model_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_model_get", _wrap_STR_NG_model_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_unit_set", _wrap_STR_NG_unit_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_unit_get", _wrap_STR_NG_unit_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_kt_set", _wrap_STR_NG_kt_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_kt_get", _wrap_STR_NG_kt_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_mass_set", _wrap_STR_NG_mass_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_mass_get", _wrap_STR_NG_mass_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_method_Pk_set", _wrap_STR_NG_method_Pk_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_method_Pk_get", _wrap_STR_NG_method_Pk_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_output_root_set", _wrap_STR_NG_output_root_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_output_root_get", _wrap_STR_NG_output_root_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_norm_set", _wrap_STR_NG_norm_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_norm_get", _wrap_STR_NG_norm_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_k_min_set", _wrap_STR_NG_k_min_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_k_min_get", _wrap_STR_NG_k_min_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_k_max_set", _wrap_STR_NG_k_max_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_k_max_get", _wrap_STR_NG_k_max_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_GSL_set", _wrap_STR_NG_GSL_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_GSL_get", _wrap_STR_NG_GSL_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_prec_set", _wrap_STR_NG_prec_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_prec_get", _wrap_STR_NG_prec_get, METH_VARARGS, NULL},
	 { (char *)"STR_NG_file_par_set", _wrap_STR_NG_file_par_set, METH_VARARGS, NULL},
	 { (char *)"STR_NG_file_par_get", _wrap_STR_NG_file_par_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_NG", _wrap_new_STR_NG, METH_VARARGS, NULL},
	 { (char *)"delete_STR_NG", _wrap_delete_STR_NG, METH_VARARGS, NULL},
	 { (char *)"STR_NG_swigregister", STR_NG_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_ChainMesh", _wrap_delete_ChainMesh, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_set_par", _wrap_ChainMesh_set_par, METH_VARARGS, NULL},
	 { (char *)"new_ChainMesh", _wrap_new_ChainMesh, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_nCell", _wrap_ChainMesh_nCell, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_pos_to_index", _wrap_ChainMesh_pos_to_index, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_inds_to_index", _wrap_ChainMesh_inds_to_index, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_index_to_inds", _wrap_ChainMesh_index_to_inds, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_create_chain_mesh", _wrap_ChainMesh_create_chain_mesh, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_create_chain_mesh_m2", _wrap_ChainMesh_create_chain_mesh_m2, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_get_searching_region", _wrap_ChainMesh_get_searching_region, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_close_objects", _wrap_ChainMesh_close_objects, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_get_list", _wrap_ChainMesh_get_list, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_swigregister", ChainMesh_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_ChainMesh1D", _wrap_delete_ChainMesh1D, METH_VARARGS, NULL},
	 { (char *)"ChainMesh1D_set_par", _wrap_ChainMesh1D_set_par, METH_VARARGS, NULL},
	 { (char *)"new_ChainMesh1D", _wrap_new_ChainMesh1D, METH_VARARGS, NULL},
	 { (char *)"ChainMesh1D_swigregister", ChainMesh1D_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_ChainMesh2D", _wrap_delete_ChainMesh2D, METH_VARARGS, NULL},
	 { (char *)"ChainMesh2D_set_par", _wrap_ChainMesh2D_set_par, METH_VARARGS, NULL},
	 { (char *)"new_ChainMesh2D", _wrap_new_ChainMesh2D, METH_VARARGS, NULL},
	 { (char *)"ChainMesh2D_swigregister", ChainMesh2D_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_ChainMesh3D", _wrap_delete_ChainMesh3D, METH_VARARGS, NULL},
	 { (char *)"ChainMesh3D_set_par", _wrap_ChainMesh3D_set_par, METH_VARARGS, NULL},
	 { (char *)"new_ChainMesh3D", _wrap_new_ChainMesh3D, METH_VARARGS, NULL},
	 { (char *)"ChainMesh3D_swigregister", ChainMesh3D_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Object", _wrap_new_Object, METH_VARARGS, NULL},
	 { (char *)"delete_Object", _wrap_delete_Object, METH_VARARGS, NULL},
	 { (char *)"Object_make_Object", _wrap_Object_make_Object, METH_VARARGS, NULL},
	 { (char *)"Object_xx", _wrap_Object_xx, METH_VARARGS, NULL},
	 { (char *)"Object_yy", _wrap_Object_yy, METH_VARARGS, NULL},
	 { (char *)"Object_zz", _wrap_Object_zz, METH_VARARGS, NULL},
	 { (char *)"Object_vx", _wrap_Object_vx, METH_VARARGS, NULL},
	 { (char *)"Object_vy", _wrap_Object_vy, METH_VARARGS, NULL},
	 { (char *)"Object_vz", _wrap_Object_vz, METH_VARARGS, NULL},
	 { (char *)"Object_dc", _wrap_Object_dc, METH_VARARGS, NULL},
	 { (char *)"Object_ra", _wrap_Object_ra, METH_VARARGS, NULL},
	 { (char *)"Object_dec", _wrap_Object_dec, METH_VARARGS, NULL},
	 { (char *)"Object_redshift", _wrap_Object_redshift, METH_VARARGS, NULL},
	 { (char *)"Object_weight", _wrap_Object_weight, METH_VARARGS, NULL},
	 { (char *)"Object_region", _wrap_Object_region, METH_VARARGS, NULL},
	 { (char *)"Object_mass", _wrap_Object_mass, METH_VARARGS, NULL},
	 { (char *)"Object_magnitude", _wrap_Object_magnitude, METH_VARARGS, NULL},
	 { (char *)"Object_richness", _wrap_Object_richness, METH_VARARGS, NULL},
	 { (char *)"Object_generic", _wrap_Object_generic, METH_VARARGS, NULL},
	 { (char *)"Object_radius", _wrap_Object_radius, METH_VARARGS, NULL},
	 { (char *)"Object_coords", _wrap_Object_coords, METH_VARARGS, NULL},
	 { (char *)"Object_set_xx", _wrap_Object_set_xx, METH_VARARGS, NULL},
	 { (char *)"Object_set_yy", _wrap_Object_set_yy, METH_VARARGS, NULL},
	 { (char *)"Object_set_zz", _wrap_Object_set_zz, METH_VARARGS, NULL},
	 { (char *)"Object_set_vx", _wrap_Object_set_vx, METH_VARARGS, NULL},
	 { (char *)"Object_set_vy", _wrap_Object_set_vy, METH_VARARGS, NULL},
	 { (char *)"Object_set_vz", _wrap_Object_set_vz, METH_VARARGS, NULL},
	 { (char *)"Object_set_dc", _wrap_Object_set_dc, METH_VARARGS, NULL},
	 { (char *)"Object_set_ra", _wrap_Object_set_ra, METH_VARARGS, NULL},
	 { (char *)"Object_set_dec", _wrap_Object_set_dec, METH_VARARGS, NULL},
	 { (char *)"Object_set_redshift", _wrap_Object_set_redshift, METH_VARARGS, NULL},
	 { (char *)"Object_set_weight", _wrap_Object_set_weight, METH_VARARGS, NULL},
	 { (char *)"Object_set_region", _wrap_Object_set_region, METH_VARARGS, NULL},
	 { (char *)"Object_set_mass", _wrap_Object_set_mass, METH_VARARGS, NULL},
	 { (char *)"Object_set_magnitude", _wrap_Object_set_magnitude, METH_VARARGS, NULL},
	 { (char *)"Object_set_richness", _wrap_Object_set_richness, METH_VARARGS, NULL},
	 { (char *)"Object_set_generic", _wrap_Object_set_generic, METH_VARARGS, NULL},
	 { (char *)"Object_set_radius", _wrap_Object_set_radius, METH_VARARGS, NULL},
	 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GenericObject", _wrap_new_GenericObject, METH_VARARGS, NULL},
	 { (char *)"delete_GenericObject", _wrap_delete_GenericObject, METH_VARARGS, NULL},
	 { (char *)"GenericObject_xx", _wrap_GenericObject_xx, METH_VARARGS, NULL},
	 { (char *)"GenericObject_yy", _wrap_GenericObject_yy, METH_VARARGS, NULL},
	 { (char *)"GenericObject_zz", _wrap_GenericObject_zz, METH_VARARGS, NULL},
	 { (char *)"GenericObject_dc", _wrap_GenericObject_dc, METH_VARARGS, NULL},
	 { (char *)"GenericObject_ra", _wrap_GenericObject_ra, METH_VARARGS, NULL},
	 { (char *)"GenericObject_dec", _wrap_GenericObject_dec, METH_VARARGS, NULL},
	 { (char *)"GenericObject_redshift", _wrap_GenericObject_redshift, METH_VARARGS, NULL},
	 { (char *)"GenericObject_weight", _wrap_GenericObject_weight, METH_VARARGS, NULL},
	 { (char *)"GenericObject_region", _wrap_GenericObject_region, METH_VARARGS, NULL},
	 { (char *)"GenericObject_coords", _wrap_GenericObject_coords, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_xx", _wrap_GenericObject_set_xx, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_yy", _wrap_GenericObject_set_yy, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_zz", _wrap_GenericObject_set_zz, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_ra", _wrap_GenericObject_set_ra, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_dec", _wrap_GenericObject_set_dec, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_redshift", _wrap_GenericObject_set_redshift, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_dc", _wrap_GenericObject_set_dc, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_weight", _wrap_GenericObject_set_weight, METH_VARARGS, NULL},
	 { (char *)"GenericObject_set_region", _wrap_GenericObject_set_region, METH_VARARGS, NULL},
	 { (char *)"GenericObject_swigregister", GenericObject_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RandomObject", _wrap_new_RandomObject, METH_VARARGS, NULL},
	 { (char *)"delete_RandomObject", _wrap_delete_RandomObject, METH_VARARGS, NULL},
	 { (char *)"RandomObject_swigregister", RandomObject_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Halo", _wrap_new_Halo, METH_VARARGS, NULL},
	 { (char *)"delete_Halo", _wrap_delete_Halo, METH_VARARGS, NULL},
	 { (char *)"Halo_vx", _wrap_Halo_vx, METH_VARARGS, NULL},
	 { (char *)"Halo_vy", _wrap_Halo_vy, METH_VARARGS, NULL},
	 { (char *)"Halo_vz", _wrap_Halo_vz, METH_VARARGS, NULL},
	 { (char *)"Halo_mass", _wrap_Halo_mass, METH_VARARGS, NULL},
	 { (char *)"Halo_set_vx", _wrap_Halo_set_vx, METH_VARARGS, NULL},
	 { (char *)"Halo_set_vy", _wrap_Halo_set_vy, METH_VARARGS, NULL},
	 { (char *)"Halo_set_vz", _wrap_Halo_set_vz, METH_VARARGS, NULL},
	 { (char *)"Halo_set_mass", _wrap_Halo_set_mass, METH_VARARGS, NULL},
	 { (char *)"Halo_swigregister", Halo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Mock", _wrap_new_Mock, METH_VARARGS, NULL},
	 { (char *)"delete_Mock", _wrap_delete_Mock, METH_VARARGS, NULL},
	 { (char *)"Mock_generic", _wrap_Mock_generic, METH_VARARGS, NULL},
	 { (char *)"Mock_set_generic", _wrap_Mock_set_generic, METH_VARARGS, NULL},
	 { (char *)"Mock_swigregister", Mock_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Galaxy", _wrap_new_Galaxy, METH_VARARGS, NULL},
	 { (char *)"delete_Galaxy", _wrap_delete_Galaxy, METH_VARARGS, NULL},
	 { (char *)"Galaxy_mass", _wrap_Galaxy_mass, METH_VARARGS, NULL},
	 { (char *)"Galaxy_magnitude", _wrap_Galaxy_magnitude, METH_VARARGS, NULL},
	 { (char *)"Galaxy_set_mass", _wrap_Galaxy_set_mass, METH_VARARGS, NULL},
	 { (char *)"Galaxy_set_magnitude", _wrap_Galaxy_set_magnitude, METH_VARARGS, NULL},
	 { (char *)"Galaxy_swigregister", Galaxy_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Cluster", _wrap_new_Cluster, METH_VARARGS, NULL},
	 { (char *)"delete_Cluster", _wrap_delete_Cluster, METH_VARARGS, NULL},
	 { (char *)"Cluster_mass", _wrap_Cluster_mass, METH_VARARGS, NULL},
	 { (char *)"Cluster_richness", _wrap_Cluster_richness, METH_VARARGS, NULL},
	 { (char *)"Cluster_set_mass", _wrap_Cluster_set_mass, METH_VARARGS, NULL},
	 { (char *)"Cluster_set_richness", _wrap_Cluster_set_richness, METH_VARARGS, NULL},
	 { (char *)"Cluster_swigregister", Cluster_swigregister, METH_VARARGS, NULL},
	 { (char *)"_XX__swigconstant", _XX__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_YY__swigconstant", _YY__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_ZZ__swigconstant", _ZZ__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_RA__swigconstant", _RA__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_DEC__swigconstant", _DEC__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_REDSHIFT__swigconstant", _REDSHIFT__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_DC__swigconstant", _DC__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_WEIGHT__swigconstant", _WEIGHT__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_MASS__swigconstant", _MASS__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_RICHNESS__swigconstant", _RICHNESS__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_MAGNITUDE__swigconstant", _MAGNITUDE__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_VX__swigconstant", _VX__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_VY__swigconstant", _VY__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_VZ__swigconstant", _VZ__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_REGION__swigconstant", _REGION__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_GENERIC__swigconstant", _GENERIC__swigconstant, METH_VARARGS, NULL},
	 { (char *)"_RADIUS__swigconstant", _RADIUS__swigconstant, METH_VARARGS, NULL},
	 { (char *)"delete_Catalogue", _wrap_delete_Catalogue, METH_VARARGS, NULL},
	 { (char *)"Catalogue_xx", _wrap_Catalogue_xx, METH_VARARGS, NULL},
	 { (char *)"Catalogue_yy", _wrap_Catalogue_yy, METH_VARARGS, NULL},
	 { (char *)"Catalogue_zz", _wrap_Catalogue_zz, METH_VARARGS, NULL},
	 { (char *)"Catalogue_vx", _wrap_Catalogue_vx, METH_VARARGS, NULL},
	 { (char *)"Catalogue_vy", _wrap_Catalogue_vy, METH_VARARGS, NULL},
	 { (char *)"Catalogue_vz", _wrap_Catalogue_vz, METH_VARARGS, NULL},
	 { (char *)"Catalogue_dc", _wrap_Catalogue_dc, METH_VARARGS, NULL},
	 { (char *)"Catalogue_ra", _wrap_Catalogue_ra, METH_VARARGS, NULL},
	 { (char *)"Catalogue_dec", _wrap_Catalogue_dec, METH_VARARGS, NULL},
	 { (char *)"Catalogue_redshift", _wrap_Catalogue_redshift, METH_VARARGS, NULL},
	 { (char *)"Catalogue_weight", _wrap_Catalogue_weight, METH_VARARGS, NULL},
	 { (char *)"Catalogue_region", _wrap_Catalogue_region, METH_VARARGS, NULL},
	 { (char *)"Catalogue_Nregion", _wrap_Catalogue_Nregion, METH_VARARGS, NULL},
	 { (char *)"Catalogue_get_region_list", _wrap_Catalogue_get_region_list, METH_VARARGS, NULL},
	 { (char *)"Catalogue_mass", _wrap_Catalogue_mass, METH_VARARGS, NULL},
	 { (char *)"Catalogue_magnitude", _wrap_Catalogue_magnitude, METH_VARARGS, NULL},
	 { (char *)"Catalogue_richness", _wrap_Catalogue_richness, METH_VARARGS, NULL},
	 { (char *)"Catalogue_generic", _wrap_Catalogue_generic, METH_VARARGS, NULL},
	 { (char *)"Catalogue_radius", _wrap_Catalogue_radius, METH_VARARGS, NULL},
	 { (char *)"Catalogue_var", _wrap_Catalogue_var, METH_VARARGS, NULL},
	 { (char *)"Catalogue_object", _wrap_Catalogue_object, METH_VARARGS, NULL},
	 { (char *)"Catalogue_coordinates", _wrap_Catalogue_coordinates, METH_VARARGS, NULL},
	 { (char *)"Catalogue_set_var", _wrap_Catalogue_set_var, METH_VARARGS, NULL},
	 { (char *)"Catalogue_nObjects", _wrap_Catalogue_nObjects, METH_VARARGS, NULL},
	 { (char *)"Catalogue_resize", _wrap_Catalogue_resize, METH_VARARGS, NULL},
	 { (char *)"Catalogue_MinMax_var", _wrap_Catalogue_MinMax_var, METH_VARARGS, NULL},
	 { (char *)"Catalogue_stats_var", _wrap_Catalogue_stats_var, METH_VARARGS, NULL},
	 { (char *)"Catalogue_var_distr", _wrap_Catalogue_var_distr, METH_VARARGS, NULL},
	 { (char *)"Catalogue_weightedN", _wrap_Catalogue_weightedN, METH_VARARGS, NULL},
	 { (char *)"Catalogue_computeComovingCoordinates", _wrap_Catalogue_computeComovingCoordinates, METH_VARARGS, NULL},
	 { (char *)"Catalogue_computePolarCoordinates", _wrap_Catalogue_computePolarCoordinates, METH_VARARGS, NULL},
	 { (char *)"Catalogue_normalizeComovingCoordinates", _wrap_Catalogue_normalizeComovingCoordinates, METH_VARARGS, NULL},
	 { (char *)"Catalogue_restoreComovingCoordinates", _wrap_Catalogue_restoreComovingCoordinates, METH_VARARGS, NULL},
	 { (char *)"Catalogue_Order", _wrap_Catalogue_Order, METH_VARARGS, NULL},
	 { (char *)"Catalogue_write_comoving_coordinates", _wrap_Catalogue_write_comoving_coordinates, METH_VARARGS, NULL},
	 { (char *)"Catalogue_write_obs_coordinates", _wrap_Catalogue_write_obs_coordinates, METH_VARARGS, NULL},
	 { (char *)"Catalogue_write_coordinates", _wrap_Catalogue_write_coordinates, METH_VARARGS, NULL},
	 { (char *)"Catalogue_distance", _wrap_Catalogue_distance, METH_VARARGS, NULL},
	 { (char *)"Catalogue_angsep_xyz", _wrap_Catalogue_angsep_xyz, METH_VARARGS, NULL},
	 { (char *)"Catalogue___iadd__", _wrap_Catalogue___iadd__, METH_VARARGS, NULL},
	 { (char *)"Catalogue_cut", _wrap_Catalogue_cut, METH_VARARGS, NULL},
	 { (char *)"Catalogue_smooth", _wrap_Catalogue_smooth, METH_VARARGS, NULL},
	 { (char *)"new_Catalogue", _wrap_new_Catalogue, METH_VARARGS, NULL},
	 { (char *)"Catalogue_add_object", _wrap_Catalogue_add_object, METH_VARARGS, NULL},
	 { (char *)"Catalogue_add_objects", _wrap_Catalogue_add_objects, METH_VARARGS, NULL},
	 { (char *)"Catalogue_remove_objects", _wrap_Catalogue_remove_objects, METH_VARARGS, NULL},
	 { (char *)"Catalogue_swigregister", Catalogue_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_ChainMesh_Catalogue", _wrap_delete_ChainMesh_Catalogue, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_Catalogue_set_par", _wrap_ChainMesh_Catalogue_set_par, METH_VARARGS, NULL},
	 { (char *)"new_ChainMesh_Catalogue", _wrap_new_ChainMesh_Catalogue, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_Catalogue_get_order", _wrap_ChainMesh_Catalogue_get_order, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_Catalogue_object_list", _wrap_ChainMesh_Catalogue_object_list, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_Catalogue_catalogue", _wrap_ChainMesh_Catalogue_catalogue, METH_VARARGS, NULL},
	 { (char *)"ChainMesh_Catalogue_swigregister", ChainMesh_Catalogue_swigregister, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_iterator", _wrap_GenericObjVec_iterator, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___nonzero__", _wrap_GenericObjVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___bool__", _wrap_GenericObjVec___bool__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___len__", _wrap_GenericObjVec___len__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_pop", _wrap_GenericObjVec_pop, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___getslice__", _wrap_GenericObjVec___getslice__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___setslice__", _wrap_GenericObjVec___setslice__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___delslice__", _wrap_GenericObjVec___delslice__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___delitem__", _wrap_GenericObjVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___getitem__", _wrap_GenericObjVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec___setitem__", _wrap_GenericObjVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_append", _wrap_GenericObjVec_append, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_empty", _wrap_GenericObjVec_empty, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_size", _wrap_GenericObjVec_size, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_clear", _wrap_GenericObjVec_clear, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_swap", _wrap_GenericObjVec_swap, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_get_allocator", _wrap_GenericObjVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_begin", _wrap_GenericObjVec_begin, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_end", _wrap_GenericObjVec_end, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_rbegin", _wrap_GenericObjVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_rend", _wrap_GenericObjVec_rend, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_pop_back", _wrap_GenericObjVec_pop_back, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_erase", _wrap_GenericObjVec_erase, METH_VARARGS, NULL},
	 { (char *)"new_GenericObjVec", _wrap_new_GenericObjVec, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_push_back", _wrap_GenericObjVec_push_back, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_front", _wrap_GenericObjVec_front, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_back", _wrap_GenericObjVec_back, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_assign", _wrap_GenericObjVec_assign, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_resize", _wrap_GenericObjVec_resize, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_insert", _wrap_GenericObjVec_insert, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_reserve", _wrap_GenericObjVec_reserve, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_capacity", _wrap_GenericObjVec_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_GenericObjVec", _wrap_delete_GenericObjVec, METH_VARARGS, NULL},
	 { (char *)"GenericObjVec_swigregister", GenericObjVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_iterator", _wrap_RandomObjVec_iterator, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___nonzero__", _wrap_RandomObjVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___bool__", _wrap_RandomObjVec___bool__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___len__", _wrap_RandomObjVec___len__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_pop", _wrap_RandomObjVec_pop, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___getslice__", _wrap_RandomObjVec___getslice__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___setslice__", _wrap_RandomObjVec___setslice__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___delslice__", _wrap_RandomObjVec___delslice__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___delitem__", _wrap_RandomObjVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___getitem__", _wrap_RandomObjVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec___setitem__", _wrap_RandomObjVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_append", _wrap_RandomObjVec_append, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_empty", _wrap_RandomObjVec_empty, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_size", _wrap_RandomObjVec_size, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_clear", _wrap_RandomObjVec_clear, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_swap", _wrap_RandomObjVec_swap, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_get_allocator", _wrap_RandomObjVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_begin", _wrap_RandomObjVec_begin, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_end", _wrap_RandomObjVec_end, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_rbegin", _wrap_RandomObjVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_rend", _wrap_RandomObjVec_rend, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_pop_back", _wrap_RandomObjVec_pop_back, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_erase", _wrap_RandomObjVec_erase, METH_VARARGS, NULL},
	 { (char *)"new_RandomObjVec", _wrap_new_RandomObjVec, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_push_back", _wrap_RandomObjVec_push_back, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_front", _wrap_RandomObjVec_front, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_back", _wrap_RandomObjVec_back, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_assign", _wrap_RandomObjVec_assign, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_resize", _wrap_RandomObjVec_resize, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_insert", _wrap_RandomObjVec_insert, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_reserve", _wrap_RandomObjVec_reserve, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_capacity", _wrap_RandomObjVec_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_RandomObjVec", _wrap_delete_RandomObjVec, METH_VARARGS, NULL},
	 { (char *)"RandomObjVec_swigregister", RandomObjVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"MockVec_iterator", _wrap_MockVec_iterator, METH_VARARGS, NULL},
	 { (char *)"MockVec___nonzero__", _wrap_MockVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MockVec___bool__", _wrap_MockVec___bool__, METH_VARARGS, NULL},
	 { (char *)"MockVec___len__", _wrap_MockVec___len__, METH_VARARGS, NULL},
	 { (char *)"MockVec_pop", _wrap_MockVec_pop, METH_VARARGS, NULL},
	 { (char *)"MockVec___getslice__", _wrap_MockVec___getslice__, METH_VARARGS, NULL},
	 { (char *)"MockVec___setslice__", _wrap_MockVec___setslice__, METH_VARARGS, NULL},
	 { (char *)"MockVec___delslice__", _wrap_MockVec___delslice__, METH_VARARGS, NULL},
	 { (char *)"MockVec___delitem__", _wrap_MockVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"MockVec___getitem__", _wrap_MockVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"MockVec___setitem__", _wrap_MockVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"MockVec_append", _wrap_MockVec_append, METH_VARARGS, NULL},
	 { (char *)"MockVec_empty", _wrap_MockVec_empty, METH_VARARGS, NULL},
	 { (char *)"MockVec_size", _wrap_MockVec_size, METH_VARARGS, NULL},
	 { (char *)"MockVec_clear", _wrap_MockVec_clear, METH_VARARGS, NULL},
	 { (char *)"MockVec_swap", _wrap_MockVec_swap, METH_VARARGS, NULL},
	 { (char *)"MockVec_get_allocator", _wrap_MockVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MockVec_begin", _wrap_MockVec_begin, METH_VARARGS, NULL},
	 { (char *)"MockVec_end", _wrap_MockVec_end, METH_VARARGS, NULL},
	 { (char *)"MockVec_rbegin", _wrap_MockVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"MockVec_rend", _wrap_MockVec_rend, METH_VARARGS, NULL},
	 { (char *)"MockVec_pop_back", _wrap_MockVec_pop_back, METH_VARARGS, NULL},
	 { (char *)"MockVec_erase", _wrap_MockVec_erase, METH_VARARGS, NULL},
	 { (char *)"new_MockVec", _wrap_new_MockVec, METH_VARARGS, NULL},
	 { (char *)"MockVec_push_back", _wrap_MockVec_push_back, METH_VARARGS, NULL},
	 { (char *)"MockVec_front", _wrap_MockVec_front, METH_VARARGS, NULL},
	 { (char *)"MockVec_back", _wrap_MockVec_back, METH_VARARGS, NULL},
	 { (char *)"MockVec_assign", _wrap_MockVec_assign, METH_VARARGS, NULL},
	 { (char *)"MockVec_resize", _wrap_MockVec_resize, METH_VARARGS, NULL},
	 { (char *)"MockVec_insert", _wrap_MockVec_insert, METH_VARARGS, NULL},
	 { (char *)"MockVec_reserve", _wrap_MockVec_reserve, METH_VARARGS, NULL},
	 { (char *)"MockVec_capacity", _wrap_MockVec_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_MockVec", _wrap_delete_MockVec, METH_VARARGS, NULL},
	 { (char *)"MockVec_swigregister", MockVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"HaloVec_iterator", _wrap_HaloVec_iterator, METH_VARARGS, NULL},
	 { (char *)"HaloVec___nonzero__", _wrap_HaloVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"HaloVec___bool__", _wrap_HaloVec___bool__, METH_VARARGS, NULL},
	 { (char *)"HaloVec___len__", _wrap_HaloVec___len__, METH_VARARGS, NULL},
	 { (char *)"HaloVec_pop", _wrap_HaloVec_pop, METH_VARARGS, NULL},
	 { (char *)"HaloVec___getslice__", _wrap_HaloVec___getslice__, METH_VARARGS, NULL},
	 { (char *)"HaloVec___setslice__", _wrap_HaloVec___setslice__, METH_VARARGS, NULL},
	 { (char *)"HaloVec___delslice__", _wrap_HaloVec___delslice__, METH_VARARGS, NULL},
	 { (char *)"HaloVec___delitem__", _wrap_HaloVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"HaloVec___getitem__", _wrap_HaloVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"HaloVec___setitem__", _wrap_HaloVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"HaloVec_append", _wrap_HaloVec_append, METH_VARARGS, NULL},
	 { (char *)"HaloVec_empty", _wrap_HaloVec_empty, METH_VARARGS, NULL},
	 { (char *)"HaloVec_size", _wrap_HaloVec_size, METH_VARARGS, NULL},
	 { (char *)"HaloVec_clear", _wrap_HaloVec_clear, METH_VARARGS, NULL},
	 { (char *)"HaloVec_swap", _wrap_HaloVec_swap, METH_VARARGS, NULL},
	 { (char *)"HaloVec_get_allocator", _wrap_HaloVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"HaloVec_begin", _wrap_HaloVec_begin, METH_VARARGS, NULL},
	 { (char *)"HaloVec_end", _wrap_HaloVec_end, METH_VARARGS, NULL},
	 { (char *)"HaloVec_rbegin", _wrap_HaloVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"HaloVec_rend", _wrap_HaloVec_rend, METH_VARARGS, NULL},
	 { (char *)"HaloVec_pop_back", _wrap_HaloVec_pop_back, METH_VARARGS, NULL},
	 { (char *)"HaloVec_erase", _wrap_HaloVec_erase, METH_VARARGS, NULL},
	 { (char *)"new_HaloVec", _wrap_new_HaloVec, METH_VARARGS, NULL},
	 { (char *)"HaloVec_push_back", _wrap_HaloVec_push_back, METH_VARARGS, NULL},
	 { (char *)"HaloVec_front", _wrap_HaloVec_front, METH_VARARGS, NULL},
	 { (char *)"HaloVec_back", _wrap_HaloVec_back, METH_VARARGS, NULL},
	 { (char *)"HaloVec_assign", _wrap_HaloVec_assign, METH_VARARGS, NULL},
	 { (char *)"HaloVec_resize", _wrap_HaloVec_resize, METH_VARARGS, NULL},
	 { (char *)"HaloVec_insert", _wrap_HaloVec_insert, METH_VARARGS, NULL},
	 { (char *)"HaloVec_reserve", _wrap_HaloVec_reserve, METH_VARARGS, NULL},
	 { (char *)"HaloVec_capacity", _wrap_HaloVec_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_HaloVec", _wrap_delete_HaloVec, METH_VARARGS, NULL},
	 { (char *)"HaloVec_swigregister", HaloVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_iterator", _wrap_GalaxyVec_iterator, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___nonzero__", _wrap_GalaxyVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___bool__", _wrap_GalaxyVec___bool__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___len__", _wrap_GalaxyVec___len__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_pop", _wrap_GalaxyVec_pop, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___getslice__", _wrap_GalaxyVec___getslice__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___setslice__", _wrap_GalaxyVec___setslice__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___delslice__", _wrap_GalaxyVec___delslice__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___delitem__", _wrap_GalaxyVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___getitem__", _wrap_GalaxyVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec___setitem__", _wrap_GalaxyVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_append", _wrap_GalaxyVec_append, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_empty", _wrap_GalaxyVec_empty, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_size", _wrap_GalaxyVec_size, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_clear", _wrap_GalaxyVec_clear, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_swap", _wrap_GalaxyVec_swap, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_get_allocator", _wrap_GalaxyVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_begin", _wrap_GalaxyVec_begin, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_end", _wrap_GalaxyVec_end, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_rbegin", _wrap_GalaxyVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_rend", _wrap_GalaxyVec_rend, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_pop_back", _wrap_GalaxyVec_pop_back, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_erase", _wrap_GalaxyVec_erase, METH_VARARGS, NULL},
	 { (char *)"new_GalaxyVec", _wrap_new_GalaxyVec, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_push_back", _wrap_GalaxyVec_push_back, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_front", _wrap_GalaxyVec_front, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_back", _wrap_GalaxyVec_back, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_assign", _wrap_GalaxyVec_assign, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_resize", _wrap_GalaxyVec_resize, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_insert", _wrap_GalaxyVec_insert, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_reserve", _wrap_GalaxyVec_reserve, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_capacity", _wrap_GalaxyVec_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_GalaxyVec", _wrap_delete_GalaxyVec, METH_VARARGS, NULL},
	 { (char *)"GalaxyVec_swigregister", GalaxyVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_iterator", _wrap_ClusterVec_iterator, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___nonzero__", _wrap_ClusterVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___bool__", _wrap_ClusterVec___bool__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___len__", _wrap_ClusterVec___len__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_pop", _wrap_ClusterVec_pop, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___getslice__", _wrap_ClusterVec___getslice__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___setslice__", _wrap_ClusterVec___setslice__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___delslice__", _wrap_ClusterVec___delslice__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___delitem__", _wrap_ClusterVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___getitem__", _wrap_ClusterVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec___setitem__", _wrap_ClusterVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_append", _wrap_ClusterVec_append, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_empty", _wrap_ClusterVec_empty, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_size", _wrap_ClusterVec_size, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_clear", _wrap_ClusterVec_clear, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_swap", _wrap_ClusterVec_swap, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_get_allocator", _wrap_ClusterVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_begin", _wrap_ClusterVec_begin, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_end", _wrap_ClusterVec_end, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_rbegin", _wrap_ClusterVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_rend", _wrap_ClusterVec_rend, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_pop_back", _wrap_ClusterVec_pop_back, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_erase", _wrap_ClusterVec_erase, METH_VARARGS, NULL},
	 { (char *)"new_ClusterVec", _wrap_new_ClusterVec, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_push_back", _wrap_ClusterVec_push_back, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_front", _wrap_ClusterVec_front, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_back", _wrap_ClusterVec_back, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_assign", _wrap_ClusterVec_assign, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_resize", _wrap_ClusterVec_resize, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_insert", _wrap_ClusterVec_insert, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_reserve", _wrap_ClusterVec_reserve, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_capacity", _wrap_ClusterVec_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_ClusterVec", _wrap_delete_ClusterVec, METH_VARARGS, NULL},
	 { (char *)"ClusterVec_swigregister", ClusterVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ObjectPtr", _wrap_new_ObjectPtr, METH_VARARGS, NULL},
	 { (char *)"delete_ObjectPtr", _wrap_delete_ObjectPtr, METH_VARARGS, NULL},
	 { (char *)"ObjectPtr_swigregister", ObjectPtr_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_LogNormal", _wrap_delete_LogNormal, METH_VARARGS, NULL},
	 { (char *)"new_LogNormal", _wrap_new_LogNormal, METH_VARARGS, NULL},
	 { (char *)"LogNormal_setCatalogues", _wrap_LogNormal_setCatalogues, METH_VARARGS, NULL},
	 { (char *)"LogNormal_setParameters_from_xi", _wrap_LogNormal_setParameters_from_xi, METH_VARARGS, NULL},
	 { (char *)"LogNormal_setParameters_from_model", _wrap_LogNormal_setParameters_from_model, METH_VARARGS, NULL},
	 { (char *)"LogNormal_set_nLN", _wrap_LogNormal_set_nLN, METH_VARARGS, NULL},
	 { (char *)"LogNormal_nLN", _wrap_LogNormal_nLN, METH_VARARGS, NULL},
	 { (char *)"LogNormal_LNCat", _wrap_LogNormal_LNCat, METH_VARARGS, NULL},
	 { (char *)"LogNormal_generate_LogNormal_mock", _wrap_LogNormal_generate_LogNormal_mock, METH_VARARGS, NULL},
	 { (char *)"LogNormal_swigregister", LogNormal_swigregister, METH_VARARGS, NULL},
	 { (char *)"random_catalogue_fromFile", _wrap_random_catalogue_fromFile, METH_VARARGS, NULL},
	 { (char *)"random_catalogue_radecred_fromFile", _wrap_random_catalogue_radecred_fromFile, METH_VARARGS, NULL},
	 { (char *)"random_catalogue_box", _wrap_random_catalogue_box, METH_VARARGS, NULL},
	 { (char *)"warped_random_catalogue", _wrap_warped_random_catalogue, METH_VARARGS, NULL},
	 { (char *)"random_catalogue_cone", _wrap_random_catalogue_cone, METH_VARARGS, NULL},
	 { (char *)"random_catalogue_mock", _wrap_random_catalogue_mock, METH_VARARGS, NULL},
	 { (char *)"random_redshift_distribution", _wrap_random_redshift_distribution, METH_VARARGS, NULL},
	 { (char *)"random_catalogue_mock_cone", _wrap_random_catalogue_mock_cone, METH_VARARGS, NULL},
	 { (char *)"random_catalogue_VIPERS", _wrap_random_catalogue_VIPERS, METH_VARARGS, NULL},
	 { (char *)"random_sdss_angular_distribution", _wrap_random_sdss_angular_distribution, METH_VARARGS, NULL},
	 { (char *)"delete_Pairs", _wrap_delete_Pairs, METH_VARARGS, NULL},
	 { (char *)"Pairs_nlog", _wrap_Pairs_nlog, METH_VARARGS, NULL},
	 { (char *)"Pairs_nlin", _wrap_Pairs_nlin, METH_VARARGS, NULL},
	 { (char *)"Pairs_ncos", _wrap_Pairs_ncos, METH_VARARGS, NULL},
	 { (char *)"Pairs_thetaMin", _wrap_Pairs_thetaMin, METH_VARARGS, NULL},
	 { (char *)"Pairs_thetaMax", _wrap_Pairs_thetaMax, METH_VARARGS, NULL},
	 { (char *)"Pairs_rMin", _wrap_Pairs_rMin, METH_VARARGS, NULL},
	 { (char *)"Pairs_rMax", _wrap_Pairs_rMax, METH_VARARGS, NULL},
	 { (char *)"Pairs_PPlog", _wrap_Pairs_PPlog, METH_VARARGS, NULL},
	 { (char *)"Pairs_PPlin", _wrap_Pairs_PPlin, METH_VARARGS, NULL},
	 { (char *)"Pairs_PP2d", _wrap_Pairs_PP2d, METH_VARARGS, NULL},
	 { (char *)"Pairs_PPslog", _wrap_Pairs_PPslog, METH_VARARGS, NULL},
	 { (char *)"Pairs_PPcoslog", _wrap_Pairs_PPcoslog, METH_VARARGS, NULL},
	 { (char *)"Pairs_PPcoslin", _wrap_Pairs_PPcoslin, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_nlog", _wrap_Pairs_set_nlog, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_nlin", _wrap_Pairs_set_nlin, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_ncos", _wrap_Pairs_set_ncos, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_rMin", _wrap_Pairs_set_rMin, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_rMax", _wrap_Pairs_set_rMax, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_thetaMin", _wrap_Pairs_set_thetaMin, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_thetaMax", _wrap_Pairs_set_thetaMax, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_logbinSize_inv", _wrap_Pairs_set_logbinSize_inv, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_linbinSize_inv", _wrap_Pairs_set_linbinSize_inv, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_cosbinSize_inv", _wrap_Pairs_set_cosbinSize_inv, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_PPlog", _wrap_Pairs_set_PPlog, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_PPlin", _wrap_Pairs_set_PPlin, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_PP2d", _wrap_Pairs_set_PP2d, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_PPslog", _wrap_Pairs_set_PPslog, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_PPcoslog", _wrap_Pairs_set_PPcoslog, METH_VARARGS, NULL},
	 { (char *)"Pairs_set_PPcoslin", _wrap_Pairs_set_PPcoslin, METH_VARARGS, NULL},
	 { (char *)"Pairs_sum_1D_log", _wrap_Pairs_sum_1D_log, METH_VARARGS, NULL},
	 { (char *)"Pairs_sum_1D_lin", _wrap_Pairs_sum_1D_lin, METH_VARARGS, NULL},
	 { (char *)"Pairs_sum_2D_linlin", _wrap_Pairs_sum_2D_linlin, METH_VARARGS, NULL},
	 { (char *)"Pairs_sum_2D_loglin", _wrap_Pairs_sum_2D_loglin, METH_VARARGS, NULL},
	 { (char *)"Pairs_sum_2Drcos_loglin", _wrap_Pairs_sum_2Drcos_loglin, METH_VARARGS, NULL},
	 { (char *)"Pairs_sum_2Drcos_linlin", _wrap_Pairs_sum_2Drcos_linlin, METH_VARARGS, NULL},
	 { (char *)"Pairs_sum_all", _wrap_Pairs_sum_all, METH_VARARGS, NULL},
	 { (char *)"Pairs_put_1D_log", _wrap_Pairs_put_1D_log, METH_VARARGS, NULL},
	 { (char *)"Pairs_put_1D_lin", _wrap_Pairs_put_1D_lin, METH_VARARGS, NULL},
	 { (char *)"Pairs_put_2D_linlin", _wrap_Pairs_put_2D_linlin, METH_VARARGS, NULL},
	 { (char *)"Pairs_put_2D_loglin", _wrap_Pairs_put_2D_loglin, METH_VARARGS, NULL},
	 { (char *)"Pairs_put_2Drcos_loglin", _wrap_Pairs_put_2Drcos_loglin, METH_VARARGS, NULL},
	 { (char *)"Pairs_put_2Drcos_linlin", _wrap_Pairs_put_2Drcos_linlin, METH_VARARGS, NULL},
	 { (char *)"Pairs_put_all", _wrap_Pairs_put_all, METH_VARARGS, NULL},
	 { (char *)"new_Pairs", _wrap_new_Pairs, METH_VARARGS, NULL},
	 { (char *)"Pairs_swigregister", Pairs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Pairs2D", _wrap_new_Pairs2D, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_nlog", _wrap_Pairs2D_nlog, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_nlin", _wrap_Pairs2D_nlin, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_thetaMin", _wrap_Pairs2D_thetaMin, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_thetaMax", _wrap_Pairs2D_thetaMax, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_PPlog", _wrap_Pairs2D_PPlog, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_PPlin", _wrap_Pairs2D_PPlin, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_set_nlog", _wrap_Pairs2D_set_nlog, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_set_nlin", _wrap_Pairs2D_set_nlin, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_set_thetaMin", _wrap_Pairs2D_set_thetaMin, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_set_thetaMax", _wrap_Pairs2D_set_thetaMax, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_set_logbinSize_inv", _wrap_Pairs2D_set_logbinSize_inv, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_set_linbinSize_inv", _wrap_Pairs2D_set_linbinSize_inv, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_set_PPlog", _wrap_Pairs2D_set_PPlog, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_set_PPlin", _wrap_Pairs2D_set_PPlin, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_sum_all", _wrap_Pairs2D_sum_all, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_put_all", _wrap_Pairs2D_put_all, METH_VARARGS, NULL},
	 { (char *)"delete_Pairs2D", _wrap_delete_Pairs2D, METH_VARARGS, NULL},
	 { (char *)"Pairs2D_swigregister", Pairs2D_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Pairs3D", _wrap_new_Pairs3D, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_nlog", _wrap_Pairs3D_nlog, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_nlin", _wrap_Pairs3D_nlin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_ncos", _wrap_Pairs3D_ncos, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_rMin", _wrap_Pairs3D_rMin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_rMax", _wrap_Pairs3D_rMax, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_PPlog", _wrap_Pairs3D_PPlog, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_PPlin", _wrap_Pairs3D_PPlin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_PP2d", _wrap_Pairs3D_PP2d, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_PPslog", _wrap_Pairs3D_PPslog, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_PPcoslog", _wrap_Pairs3D_PPcoslog, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_PPcoslin", _wrap_Pairs3D_PPcoslin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_nlog", _wrap_Pairs3D_set_nlog, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_nlin", _wrap_Pairs3D_set_nlin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_ncos", _wrap_Pairs3D_set_ncos, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_rMin", _wrap_Pairs3D_set_rMin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_rMax", _wrap_Pairs3D_set_rMax, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_logbinSize_inv", _wrap_Pairs3D_set_logbinSize_inv, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_linbinSize_inv", _wrap_Pairs3D_set_linbinSize_inv, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_cosbinSize_inv", _wrap_Pairs3D_set_cosbinSize_inv, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_PPlog", _wrap_Pairs3D_set_PPlog, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_PPlin", _wrap_Pairs3D_set_PPlin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_PP2d", _wrap_Pairs3D_set_PP2d, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_PPslog", _wrap_Pairs3D_set_PPslog, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_PPcoslog", _wrap_Pairs3D_set_PPcoslog, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_set_PPcoslin", _wrap_Pairs3D_set_PPcoslin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_sum_1D_log", _wrap_Pairs3D_sum_1D_log, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_sum_1D_lin", _wrap_Pairs3D_sum_1D_lin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_sum_2D_linlin", _wrap_Pairs3D_sum_2D_linlin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_sum_2D_loglin", _wrap_Pairs3D_sum_2D_loglin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_sum_2Drcos_loglin", _wrap_Pairs3D_sum_2Drcos_loglin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_sum_2Drcos_linlin", _wrap_Pairs3D_sum_2Drcos_linlin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_sum_all", _wrap_Pairs3D_sum_all, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_put_1D_log", _wrap_Pairs3D_put_1D_log, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_put_1D_lin", _wrap_Pairs3D_put_1D_lin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_put_2D_linlin", _wrap_Pairs3D_put_2D_linlin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_put_2D_loglin", _wrap_Pairs3D_put_2D_loglin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_put_2Drcos_loglin", _wrap_Pairs3D_put_2Drcos_loglin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_put_2Drcos_linlin", _wrap_Pairs3D_put_2Drcos_linlin, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_put_all", _wrap_Pairs3D_put_all, METH_VARARGS, NULL},
	 { (char *)"delete_Pairs3D", _wrap_delete_Pairs3D, METH_VARARGS, NULL},
	 { (char *)"Pairs3D_swigregister", Pairs3D_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_TwoPointCorrelation", _wrap_delete_TwoPointCorrelation, METH_VARARGS, NULL},
	 { (char *)"new_TwoPointCorrelation", _wrap_new_TwoPointCorrelation, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_setParameters", _wrap_TwoPointCorrelation_setParameters, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_allocate_vectors_xi", _wrap_TwoPointCorrelation_allocate_vectors_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_allocate_vectors_ACF", _wrap_TwoPointCorrelation_allocate_vectors_ACF, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_erase_multipoles", _wrap_TwoPointCorrelation_erase_multipoles, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_write_xi", _wrap_TwoPointCorrelation_write_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_count_pairs_regions", _wrap_TwoPointCorrelation_count_pairs_regions, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_xi", _wrap_TwoPointCorrelation_measure_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_get_covariance", _wrap_TwoPointCorrelation_get_covariance, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_gg_pairs", _wrap_TwoPointCorrelation_set_gg_pairs, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_rr_pairs", _wrap_TwoPointCorrelation_set_rr_pairs, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_gr_pairs", _wrap_TwoPointCorrelation_set_gr_pairs, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_write_pairs_subSamples", _wrap_TwoPointCorrelation_write_pairs_subSamples, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_read_pairs_subSamples", _wrap_TwoPointCorrelation_read_pairs_subSamples, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_write_xi_Mocks", _wrap_TwoPointCorrelation_write_xi_Mocks, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_projected_xi_Mocks", _wrap_TwoPointCorrelation_measure_projected_xi_Mocks, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_wtheta", _wrap_TwoPointCorrelation_measure_wtheta, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_write_wtheta", _wrap_TwoPointCorrelation_write_wtheta, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_Error", _wrap_TwoPointCorrelation_Error, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_covariance_1D", _wrap_TwoPointCorrelation_measure_covariance_1D, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_projected_xi", _wrap_TwoPointCorrelation_measure_projected_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_multipoles_xirmu", _wrap_TwoPointCorrelation_measure_multipoles_xirmu, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_multipoles_xirppi", _wrap_TwoPointCorrelation_measure_multipoles_xirppi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_effective_multipoles_xirppi", _wrap_TwoPointCorrelation_measure_effective_multipoles_xirppi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_write_multipoles", _wrap_TwoPointCorrelation_write_multipoles, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_read_multipoles", _wrap_TwoPointCorrelation_read_multipoles, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_normalized_quadrupole", _wrap_TwoPointCorrelation_measure_normalized_quadrupole, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sigmaR_obj", _wrap_TwoPointCorrelation_sigmaR_obj, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_measure_bias", _wrap_TwoPointCorrelation_measure_bias, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_mean_bias", _wrap_TwoPointCorrelation_mean_bias, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_mean_bias", _wrap_TwoPointCorrelation_error_mean_bias, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_fit_bias", _wrap_TwoPointCorrelation_fit_bias, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_read_bias", _wrap_TwoPointCorrelation_read_bias, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_compute_real_space_xi_deprojected", _wrap_TwoPointCorrelation_compute_real_space_xi_deprojected, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_derive_real_xi", _wrap_TwoPointCorrelation_derive_real_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_N_R", _wrap_TwoPointCorrelation_N_R, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_nlinbins", _wrap_TwoPointCorrelation_nlinbins, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_nlogbins", _wrap_TwoPointCorrelation_nlogbins, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_ncosbins", _wrap_TwoPointCorrelation_ncosbins, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_linbinsz", _wrap_TwoPointCorrelation_linbinsz, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_logbinsz", _wrap_TwoPointCorrelation_logbinsz, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_cosbinsz", _wrap_TwoPointCorrelation_cosbinsz, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_shift_lin", _wrap_TwoPointCorrelation_shift_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_shift_log", _wrap_TwoPointCorrelation_shift_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_shift_cos", _wrap_TwoPointCorrelation_shift_cos, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rad_log", _wrap_TwoPointCorrelation_rad_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi_log", _wrap_TwoPointCorrelation_xi_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi_log", _wrap_TwoPointCorrelation_error_xi_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rad_lin", _wrap_TwoPointCorrelation_rad_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi_lin", _wrap_TwoPointCorrelation_xi_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi_lin", _wrap_TwoPointCorrelation_error_xi_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi_2d_lin", _wrap_TwoPointCorrelation_xi_2d_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi_2d_lin", _wrap_TwoPointCorrelation_error_xi_2d_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rad_real_lin", _wrap_TwoPointCorrelation_rad_real_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi_real_lin", _wrap_TwoPointCorrelation_xi_real_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi_real_lin_extr", _wrap_TwoPointCorrelation_xi_real_lin_extr, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi_real_lin_interp", _wrap_TwoPointCorrelation_xi_real_lin_interp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi_real_lin", _wrap_TwoPointCorrelation_error_xi_real_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rad_real_log", _wrap_TwoPointCorrelation_rad_real_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi_real_log", _wrap_TwoPointCorrelation_xi_real_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rp_proj", _wrap_TwoPointCorrelation_rp_proj, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi_proj", _wrap_TwoPointCorrelation_xi_proj, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi_proj", _wrap_TwoPointCorrelation_error_xi_proj, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi0_log", _wrap_TwoPointCorrelation_xi0_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi2_log", _wrap_TwoPointCorrelation_xi2_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi4_log", _wrap_TwoPointCorrelation_xi4_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi0_lin", _wrap_TwoPointCorrelation_xi0_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi2_lin", _wrap_TwoPointCorrelation_xi2_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_xi4_lin", _wrap_TwoPointCorrelation_xi4_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi0_log", _wrap_TwoPointCorrelation_error_xi0_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi2_log", _wrap_TwoPointCorrelation_error_xi2_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi4_log", _wrap_TwoPointCorrelation_error_xi4_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi0_lin", _wrap_TwoPointCorrelation_error_xi0_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi2_lin", _wrap_TwoPointCorrelation_error_xi2_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_xi4_lin", _wrap_TwoPointCorrelation_error_xi4_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_quad", _wrap_TwoPointCorrelation_quad, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_quad", _wrap_TwoPointCorrelation_error_quad, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rMIN", _wrap_TwoPointCorrelation_rMIN, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rMAX", _wrap_TwoPointCorrelation_rMAX, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rMAX_eff", _wrap_TwoPointCorrelation_rMAX_eff, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rr_bias_lin_xi", _wrap_TwoPointCorrelation_rr_bias_lin_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_bias_lin_xi", _wrap_TwoPointCorrelation_bias_lin_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_bias_lin_xi", _wrap_TwoPointCorrelation_error_bias_lin_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rr_bias_nl_xi", _wrap_TwoPointCorrelation_rr_bias_nl_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_bias_nl_xi", _wrap_TwoPointCorrelation_bias_nl_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_bias_nl_xi", _wrap_TwoPointCorrelation_error_bias_nl_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rr_bias_lin_wp", _wrap_TwoPointCorrelation_rr_bias_lin_wp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_bias_lin_wp", _wrap_TwoPointCorrelation_bias_lin_wp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_bias_lin_wp", _wrap_TwoPointCorrelation_error_bias_lin_wp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_rr_bias_nl_wp", _wrap_TwoPointCorrelation_rr_bias_nl_wp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_bias_nl_wp", _wrap_TwoPointCorrelation_bias_nl_wp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_error_bias_nl_wp", _wrap_TwoPointCorrelation_error_bias_nl_wp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_bias", _wrap_TwoPointCorrelation_bias, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_bias_min", _wrap_TwoPointCorrelation_bias_min, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_bias_max", _wrap_TwoPointCorrelation_bias_max, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_r0_linextr", _wrap_TwoPointCorrelation_r0_linextr, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_gamma_linextr", _wrap_TwoPointCorrelation_gamma_linextr, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi_log", _wrap_TwoPointCorrelation_sizeof_xi_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi_lin", _wrap_TwoPointCorrelation_sizeof_xi_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi_real_lin", _wrap_TwoPointCorrelation_sizeof_xi_real_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi_real_lin_extr", _wrap_TwoPointCorrelation_sizeof_xi_real_lin_extr, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi_real_lin_interp", _wrap_TwoPointCorrelation_sizeof_xi_real_lin_interp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi_proj", _wrap_TwoPointCorrelation_sizeof_xi_proj, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi0_log", _wrap_TwoPointCorrelation_sizeof_xi0_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi2_log", _wrap_TwoPointCorrelation_sizeof_xi2_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi4_log", _wrap_TwoPointCorrelation_sizeof_xi4_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi0_lin", _wrap_TwoPointCorrelation_sizeof_xi0_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi2_lin", _wrap_TwoPointCorrelation_sizeof_xi2_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_xi4_lin", _wrap_TwoPointCorrelation_sizeof_xi4_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_quad", _wrap_TwoPointCorrelation_sizeof_quad, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_bias_lin_xi", _wrap_TwoPointCorrelation_sizeof_bias_lin_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_bias_nl_xi", _wrap_TwoPointCorrelation_sizeof_bias_nl_xi, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_bias_lin_wp", _wrap_TwoPointCorrelation_sizeof_bias_lin_wp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_sizeof_bias_nl_wp", _wrap_TwoPointCorrelation_sizeof_bias_nl_wp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_bin_proj", _wrap_TwoPointCorrelation_bin_proj, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_nObjects", _wrap_TwoPointCorrelation_nObjects, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_Xmin", _wrap_TwoPointCorrelation_Xmin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_Xmax", _wrap_TwoPointCorrelation_Xmax, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_Ymin", _wrap_TwoPointCorrelation_Ymin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_Ymax", _wrap_TwoPointCorrelation_Ymax, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_Zmin", _wrap_TwoPointCorrelation_Zmin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_Zmax", _wrap_TwoPointCorrelation_Zmax, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_nGal", _wrap_TwoPointCorrelation_set_nGal, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_nRan", _wrap_TwoPointCorrelation_set_nRan, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_rad_log", _wrap_TwoPointCorrelation_set_rad_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_xi_log", _wrap_TwoPointCorrelation_set_xi_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_error_xi_log", _wrap_TwoPointCorrelation_set_error_xi_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_rad_lin", _wrap_TwoPointCorrelation_set_rad_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_xi_lin", _wrap_TwoPointCorrelation_set_xi_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_error_xi_lin", _wrap_TwoPointCorrelation_set_error_xi_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_error_xi_2d_lin", _wrap_TwoPointCorrelation_set_error_xi_2d_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_error_xi_2d_loglin", _wrap_TwoPointCorrelation_set_error_xi_2d_loglin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_error_xi_coslog", _wrap_TwoPointCorrelation_set_error_xi_coslog, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_error_xi_coslin", _wrap_TwoPointCorrelation_set_error_xi_coslin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_error_proj", _wrap_TwoPointCorrelation_set_error_proj, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_correlations", _wrap_TwoPointCorrelation_set_correlations, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_xi_real_log", _wrap_TwoPointCorrelation_set_xi_real_log, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_xi_real_lin", _wrap_TwoPointCorrelation_set_xi_real_lin, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_xi_real_lin_interp", _wrap_TwoPointCorrelation_set_xi_real_lin_interp, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_xi_real_lin_extr", _wrap_TwoPointCorrelation_set_xi_real_lin_extr, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_set_xi_proj", _wrap_TwoPointCorrelation_set_xi_proj, METH_VARARGS, NULL},
	 { (char *)"TwoPointCorrelation_swigregister", TwoPointCorrelation_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ModelTwoPointCorrelation", _wrap_new_ModelTwoPointCorrelation, METH_VARARGS, NULL},
	 { (char *)"delete_ModelTwoPointCorrelation", _wrap_delete_ModelTwoPointCorrelation, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_setLimitLog", _wrap_ModelTwoPointCorrelation_setLimitLog, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_setLimit", _wrap_ModelTwoPointCorrelation_setLimit, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured", _wrap_ModelTwoPointCorrelation_compute_xi2D_modelXiMeasured, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_compute_xi2D_model", _wrap_ModelTwoPointCorrelation_compute_xi2D_model, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured", _wrap_ModelTwoPointCorrelation_compute_multipoles_modelXiMeasured, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured", _wrap_ModelTwoPointCorrelation_compute_effective_multipoles_modelXiMeasured, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured", _wrap_ModelTwoPointCorrelation_measure_beta_KaiserLimit_XiMeasured, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_measure_beta_XiMeasured", _wrap_ModelTwoPointCorrelation_measure_beta_XiMeasured, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured", _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles", _wrap_ModelTwoPointCorrelation_measure_beta_sigma12_DispersionModel_XiMeasured_multipoles, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit", _wrap_ModelTwoPointCorrelation_measure_fsigma8_KaiserLimit, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_measure_fsigma8_bsigma8", _wrap_ModelTwoPointCorrelation_measure_fsigma8_bsigma8, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_relative_error_beta_catalogue", _wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_relative_error_beta_catalogue_box", _wrap_ModelTwoPointCorrelation_relative_error_beta_catalogue_box, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured", _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModelXiMeasured, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured", _wrap_ModelTwoPointCorrelation_write_multipoles_DispersionModelXiMeasured, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_write_xi2D_DispersionModel", _wrap_ModelTwoPointCorrelation_write_xi2D_DispersionModel, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_write_xi2D_CWModel", _wrap_ModelTwoPointCorrelation_write_xi2D_CWModel, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_write_map", _wrap_ModelTwoPointCorrelation_write_map, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_MhaloMin", _wrap_ModelTwoPointCorrelation_MhaloMin, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_beta_best", _wrap_ModelTwoPointCorrelation_beta_best, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_error_beta", _wrap_ModelTwoPointCorrelation_error_beta, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_sigma12_best", _wrap_ModelTwoPointCorrelation_sigma12_best, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_error_sigma12", _wrap_ModelTwoPointCorrelation_error_sigma12, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_bias_best", _wrap_ModelTwoPointCorrelation_bias_best, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_bias_sigma8_best", _wrap_ModelTwoPointCorrelation_bias_sigma8_best, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_f_sigma8_best", _wrap_ModelTwoPointCorrelation_f_sigma8_best, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_bA_best", _wrap_ModelTwoPointCorrelation_bA_best, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_E_min", _wrap_ModelTwoPointCorrelation_E_min, METH_VARARGS, NULL},
	 { (char *)"ModelTwoPointCorrelation_swigregister", ModelTwoPointCorrelation_swigregister, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_cosm_set", _wrap_STR_xi0K_cosm_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_cosm_get", _wrap_STR_xi0K_cosm_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_bias_sigma8_set", _wrap_STR_xi0K_bias_sigma8_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_bias_sigma8_get", _wrap_STR_xi0K_bias_sigma8_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_author_set", _wrap_STR_xi0K_author_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_author_get", _wrap_STR_xi0K_author_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_redshift_set", _wrap_STR_xi0K_redshift_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_redshift_get", _wrap_STR_xi0K_redshift_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_Model_set", _wrap_STR_xi0K_Model_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_Model_get", _wrap_STR_xi0K_Model_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_xiType_set", _wrap_STR_xi0K_xiType_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_xiType_get", _wrap_STR_xi0K_xiType_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_k_star_set", _wrap_STR_xi0K_k_star_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_k_star_get", _wrap_STR_xi0K_k_star_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_xiNL_set", _wrap_STR_xi0K_xiNL_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_xiNL_get", _wrap_STR_xi0K_xiNL_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_v_min_set", _wrap_STR_xi0K_v_min_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_v_min_get", _wrap_STR_xi0K_v_min_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_v_max_set", _wrap_STR_xi0K_v_max_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_v_max_get", _wrap_STR_xi0K_v_max_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_step_v_set", _wrap_STR_xi0K_step_v_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_step_v_get", _wrap_STR_xi0K_step_v_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_norm_set", _wrap_STR_xi0K_norm_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_norm_get", _wrap_STR_xi0K_norm_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_r_min_set", _wrap_STR_xi0K_r_min_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_r_min_get", _wrap_STR_xi0K_r_min_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_r_max_set", _wrap_STR_xi0K_r_max_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_r_max_get", _wrap_STR_xi0K_r_max_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_k_min_set", _wrap_STR_xi0K_k_min_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_k_min_get", _wrap_STR_xi0K_k_min_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_k_max_set", _wrap_STR_xi0K_k_max_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_k_max_get", _wrap_STR_xi0K_k_max_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_aa_set", _wrap_STR_xi0K_aa_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_aa_get", _wrap_STR_xi0K_aa_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_GSL_set", _wrap_STR_xi0K_GSL_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_GSL_get", _wrap_STR_xi0K_GSL_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_prec_set", _wrap_STR_xi0K_prec_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_prec_get", _wrap_STR_xi0K_prec_get, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_file_par_set", _wrap_STR_xi0K_file_par_set, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_file_par_get", _wrap_STR_xi0K_file_par_get, METH_VARARGS, NULL},
	 { (char *)"new_STR_xi0K", _wrap_new_STR_xi0K, METH_VARARGS, NULL},
	 { (char *)"delete_STR_xi0K", _wrap_delete_STR_xi0K, METH_VARARGS, NULL},
	 { (char *)"STR_xi0K_swigregister", STR_xi0K_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Triplets", _wrap_delete_Triplets, METH_VARARGS, NULL},
	 { (char *)"Triplets_binsize", _wrap_Triplets_binsize, METH_VARARGS, NULL},
	 { (char *)"Triplets_side_s", _wrap_Triplets_side_s, METH_VARARGS, NULL},
	 { (char *)"Triplets_side_u", _wrap_Triplets_side_u, METH_VARARGS, NULL},
	 { (char *)"Triplets_perc_increase", _wrap_Triplets_perc_increase, METH_VARARGS, NULL},
	 { (char *)"Triplets_TT", _wrap_Triplets_TT, METH_VARARGS, NULL},
	 { (char *)"Triplets_sum", _wrap_Triplets_sum, METH_VARARGS, NULL},
	 { (char *)"Triplets_put", _wrap_Triplets_put, METH_VARARGS, NULL},
	 { (char *)"new_Triplets", _wrap_new_Triplets, METH_VARARGS, NULL},
	 { (char *)"Triplets_swigregister", Triplets_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Triplets2D", _wrap_new_Triplets2D, METH_VARARGS, NULL},
	 { (char *)"Triplets2D_binsize", _wrap_Triplets2D_binsize, METH_VARARGS, NULL},
	 { (char *)"Triplets2D_side_s", _wrap_Triplets2D_side_s, METH_VARARGS, NULL},
	 { (char *)"Triplets2D_side_u", _wrap_Triplets2D_side_u, METH_VARARGS, NULL},
	 { (char *)"Triplets2D_perc_increase", _wrap_Triplets2D_perc_increase, METH_VARARGS, NULL},
	 { (char *)"Triplets2D_TT", _wrap_Triplets2D_TT, METH_VARARGS, NULL},
	 { (char *)"Triplets2D_sum", _wrap_Triplets2D_sum, METH_VARARGS, NULL},
	 { (char *)"Triplets2D_put", _wrap_Triplets2D_put, METH_VARARGS, NULL},
	 { (char *)"delete_Triplets2D", _wrap_delete_Triplets2D, METH_VARARGS, NULL},
	 { (char *)"Triplets2D_swigregister", Triplets2D_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Triplets3D", _wrap_new_Triplets3D, METH_VARARGS, NULL},
	 { (char *)"Triplets3D_binsize", _wrap_Triplets3D_binsize, METH_VARARGS, NULL},
	 { (char *)"Triplets3D_side_s", _wrap_Triplets3D_side_s, METH_VARARGS, NULL},
	 { (char *)"Triplets3D_side_u", _wrap_Triplets3D_side_u, METH_VARARGS, NULL},
	 { (char *)"Triplets3D_perc_increase", _wrap_Triplets3D_perc_increase, METH_VARARGS, NULL},
	 { (char *)"Triplets3D_TT", _wrap_Triplets3D_TT, METH_VARARGS, NULL},
	 { (char *)"Triplets3D_sum", _wrap_Triplets3D_sum, METH_VARARGS, NULL},
	 { (char *)"Triplets3D_put", _wrap_Triplets3D_put, METH_VARARGS, NULL},
	 { (char *)"delete_Triplets3D", _wrap_delete_Triplets3D, METH_VARARGS, NULL},
	 { (char *)"Triplets3D_swigregister", Triplets3D_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ThreePointCorrelation", _wrap_new_ThreePointCorrelation, METH_VARARGS, NULL},
	 { (char *)"delete_ThreePointCorrelation", _wrap_delete_ThreePointCorrelation, METH_VARARGS, NULL},
	 { (char *)"ThreePointCorrelation_setParameters3p", _wrap_ThreePointCorrelation_setParameters3p, METH_VARARGS, NULL},
	 { (char *)"ThreePointCorrelation_allocate_vectors_zeta", _wrap_ThreePointCorrelation_allocate_vectors_zeta, METH_VARARGS, NULL},
	 { (char *)"ThreePointCorrelation_measure_Q", _wrap_ThreePointCorrelation_measure_Q, METH_VARARGS, NULL},
	 { (char *)"ThreePointCorrelation_measure_Q_TEST", _wrap_ThreePointCorrelation_measure_Q_TEST, METH_VARARGS, NULL},
	 { (char *)"ThreePointCorrelation_measure_Q_ang", _wrap_ThreePointCorrelation_measure_Q_ang, METH_VARARGS, NULL},
	 { (char *)"ThreePointCorrelation_write_Q", _wrap_ThreePointCorrelation_write_Q, METH_VARARGS, NULL},
	 { (char *)"ThreePointCorrelation_swigregister", ThreePointCorrelation_swigregister, METH_VARARGS, NULL},
	 { (char *)"Vmax_DC_distribution", _wrap_Vmax_DC_distribution, METH_VARARGS, NULL},
	 { (char *)"AP_shift_r", _wrap_AP_shift_r, METH_VARARGS, NULL},
	 { (char *)"AP_shift_rp", _wrap_AP_shift_rp, METH_VARARGS, NULL},
	 { (char *)"AP_shift_pi", _wrap_AP_shift_pi, METH_VARARGS, NULL},
	 { (char *)"max_separations_AP", _wrap_max_separations_AP, METH_VARARGS, NULL},
	 { (char *)"converted_xi", _wrap_converted_xi, METH_VARARGS, NULL},
	 { (char *)"redshift_range", _wrap_redshift_range, METH_VARARGS, NULL},
	 { (char *)"volume", _wrap_volume, METH_VARARGS, NULL},
	 { (char *)"coord_zSpace", _wrap_coord_zSpace, METH_VARARGS, NULL},
	 { (char *)"create_mocks", _wrap_create_mocks, METH_VARARGS, NULL},
	 { (char *)"set_ObjectRegion_SubBoxes", _wrap_set_ObjectRegion_SubBoxes, METH_VARARGS, NULL},
	 { (char *)"set_ObjectRegion_mangle", _wrap_set_ObjectRegion_mangle, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_cosmobl__MockTo_p_cosmobl__Halo(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Halo *)  ((cosmobl::Mock *) x));
}
static void *_p_cosmobl__ThreePointCorrelationTo_p_cosmobl__TwoPointCorrelation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::TwoPointCorrelation *)  ((cosmobl::ThreePointCorrelation *) x));
}
static void *_p_cosmobl__Pairs3DTo_p_cosmobl__Pairs(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Pairs *)  ((cosmobl::Pairs3D *) x));
}
static void *_p_cosmobl__Pairs2DTo_p_cosmobl__Pairs(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Pairs *)  ((cosmobl::Pairs2D *) x));
}
static void *_p_cosmobl__HaloTo_p_cosmobl__GenericObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::GenericObject *)  ((cosmobl::Halo *) x));
}
static void *_p_cosmobl__MockTo_p_cosmobl__GenericObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::GenericObject *) (cosmobl::Halo *) ((cosmobl::Mock *) x));
}
static void *_p_cosmobl__GalaxyTo_p_cosmobl__GenericObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::GenericObject *)  ((cosmobl::Galaxy *) x));
}
static void *_p_cosmobl__RandomObjectTo_p_cosmobl__GenericObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::GenericObject *)  ((cosmobl::RandomObject *) x));
}
static void *_p_cosmobl__ClusterTo_p_cosmobl__GenericObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::GenericObject *)  ((cosmobl::Cluster *) x));
}
static void *_p_cosmobl__Triplets2DTo_p_cosmobl__Triplets(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Triplets *)  ((cosmobl::Triplets2D *) x));
}
static void *_p_cosmobl__Triplets3DTo_p_cosmobl__Triplets(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Triplets *)  ((cosmobl::Triplets3D *) x));
}
static void *_p_cosmobl__HaloTo_p_cosmobl__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Object *) (cosmobl::GenericObject *) ((cosmobl::Halo *) x));
}
static void *_p_cosmobl__MockTo_p_cosmobl__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Object *) (cosmobl::GenericObject *)(cosmobl::Halo *) ((cosmobl::Mock *) x));
}
static void *_p_cosmobl__GalaxyTo_p_cosmobl__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Object *) (cosmobl::GenericObject *) ((cosmobl::Galaxy *) x));
}
static void *_p_cosmobl__GenericObjectTo_p_cosmobl__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Object *)  ((cosmobl::GenericObject *) x));
}
static void *_p_cosmobl__RandomObjectTo_p_cosmobl__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Object *) (cosmobl::GenericObject *) ((cosmobl::RandomObject *) x));
}
static void *_p_cosmobl__ClusterTo_p_cosmobl__Object(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::Object *) (cosmobl::GenericObject *) ((cosmobl::Cluster *) x));
}
static void *_p_cosmobl__ChainMesh1DTo_p_cosmobl__ChainMesh(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::ChainMesh *)  ((cosmobl::ChainMesh1D *) x));
}
static void *_p_cosmobl__ChainMesh3DTo_p_cosmobl__ChainMesh(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::ChainMesh *)  ((cosmobl::ChainMesh3D *) x));
}
static void *_p_cosmobl__ChainMesh_CatalogueTo_p_cosmobl__ChainMesh(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::ChainMesh *)  ((cosmobl::ChainMesh_Catalogue *) x));
}
static void *_p_cosmobl__ChainMesh2DTo_p_cosmobl__ChainMesh(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((cosmobl::ChainMesh *)  ((cosmobl::ChainMesh2D *) x));
}
static swig_type_info _swigt__p_Doub = {"_p_Doub", "Doub *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MatDoub = {"_p_MatDoub", "MatDoub *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VecDoub = {"_p_VecDoub", "VecDoub *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Catalogue = {"_p_cosmobl__Catalogue", "cosmobl::Catalogue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__ChainMesh = {"_p_cosmobl__ChainMesh", "cosmobl::ChainMesh *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__ChainMesh1D = {"_p_cosmobl__ChainMesh1D", "cosmobl::ChainMesh1D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__ChainMesh2D = {"_p_cosmobl__ChainMesh2D", "cosmobl::ChainMesh2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__ChainMesh3D = {"_p_cosmobl__ChainMesh3D", "cosmobl::ChainMesh3D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__ChainMesh_Catalogue = {"_p_cosmobl__ChainMesh_Catalogue", "cosmobl::ChainMesh_Catalogue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Cluster = {"_p_cosmobl__Cluster", "cosmobl::Cluster *|vector< cosmobl::Cluster >::value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Cosmology = {"_p_cosmobl__Cosmology", "cosmobl::Cosmology *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Galaxy = {"_p_cosmobl__Galaxy", "vector< cosmobl::Galaxy >::value_type *|cosmobl::Galaxy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__GenericObject = {"_p_cosmobl__GenericObject", "vector< cosmobl::GenericObject >::value_type *|cosmobl::GenericObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Halo = {"_p_cosmobl__Halo", "vector< cosmobl::Halo >::value_type *|cosmobl::Halo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__LogNormal = {"_p_cosmobl__LogNormal", "cosmobl::LogNormal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Mock = {"_p_cosmobl__Mock", "vector< cosmobl::Mock >::value_type *|cosmobl::Mock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__ModelTwoPointCorrelation = {"_p_cosmobl__ModelTwoPointCorrelation", "cosmobl::ModelTwoPointCorrelation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Object = {"_p_cosmobl__Object", "cosmobl::Object *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Pairs = {"_p_cosmobl__Pairs", "cosmobl::Pairs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Pairs2D = {"_p_cosmobl__Pairs2D", "cosmobl::Pairs2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Pairs3D = {"_p_cosmobl__Pairs3D", "cosmobl::Pairs3D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__RandomObject = {"_p_cosmobl__RandomObject", "vector< cosmobl::RandomObject >::value_type *|cosmobl::RandomObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__ThreePointCorrelation = {"_p_cosmobl__ThreePointCorrelation", "cosmobl::ThreePointCorrelation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Triplets = {"_p_cosmobl__Triplets", "cosmobl::Triplets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Triplets2D = {"_p_cosmobl__Triplets2D", "cosmobl::Triplets2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__Triplets3D = {"_p_cosmobl__Triplets3D", "cosmobl::Triplets3D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__TwoPointCorrelation = {"_p_cosmobl__TwoPointCorrelation", "cosmobl::TwoPointCorrelation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__CL = {"_p_cosmobl__glob__CL", "cosmobl::glob::CL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__GSL_f_pars = {"_p_cosmobl__glob__GSL_f_pars", "cosmobl::glob::GSL_f_pars *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_NG = {"_p_cosmobl__glob__STR_NG", "cosmobl::glob::STR_NG *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_SSM = {"_p_cosmobl__glob__STR_SSM", "cosmobl::glob::STR_SSM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_SSM_EH = {"_p_cosmobl__glob__STR_SSM_EH", "cosmobl::glob::STR_SSM_EH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_grid = {"_p_cosmobl__glob__STR_grid", "cosmobl::glob::STR_grid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_grid_2D = {"_p_cosmobl__glob__STR_grid_2D", "cosmobl::glob::STR_grid_2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_xi = {"_p_cosmobl__glob__STR_xi", "cosmobl::glob::STR_xi *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_xi0K = {"_p_cosmobl__glob__STR_xi0K", "cosmobl::glob::STR_xi0K *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_xi0_model = {"_p_cosmobl__glob__STR_xi0_model", "cosmobl::glob::STR_xi0_model *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_xi2D_model = {"_p_cosmobl__glob__STR_xi2D_model", "cosmobl::glob::STR_xi2D_model *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cosmobl__glob__STR_xi_EH = {"_p_cosmobl__glob__STR_xi_EH", "cosmobl::glob::STR_xi_EH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_double_p_void__double = {"_p_f_double_p_void__double", "double (*)(double,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_double_size_t_p_void__double = {"_p_f_p_double_size_t_p_void__double", "double (*)(double *,size_t,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_q_const__double__double = {"_p_f_q_const__double__double", "double (*)(double const)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_q_const__double_q_const__double__double = {"_p_f_q_const__double_q_const__double__double", "double (*)(double const,double const)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double = {"_p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double", "double (*)(double const,double const,double const,double const,double const,double const)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_cosmobl__Cluster_t = {"_p_std__allocatorT_cosmobl__Cluster_t", "vector< cosmobl::Cluster >::allocator_type *|std::allocator< cosmobl::Cluster > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_cosmobl__Galaxy_t = {"_p_std__allocatorT_cosmobl__Galaxy_t", "vector< cosmobl::Galaxy >::allocator_type *|std::allocator< cosmobl::Galaxy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_cosmobl__GenericObject_t = {"_p_std__allocatorT_cosmobl__GenericObject_t", "vector< cosmobl::GenericObject >::allocator_type *|std::allocator< cosmobl::GenericObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_cosmobl__Halo_t = {"_p_std__allocatorT_cosmobl__Halo_t", "vector< cosmobl::Halo >::allocator_type *|std::allocator< cosmobl::Halo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_cosmobl__Mock_t = {"_p_std__allocatorT_cosmobl__Mock_t", "vector< cosmobl::Mock >::allocator_type *|std::allocator< cosmobl::Mock > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_cosmobl__RandomObject_t = {"_p_std__allocatorT_cosmobl__RandomObject_t", "vector< cosmobl::RandomObject >::allocator_type *|std::allocator< cosmobl::RandomObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_cosmobl__Catalogue_t = {"_p_std__shared_ptrT_cosmobl__Catalogue_t", "std::shared_ptr< cosmobl::Catalogue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_cosmobl__Cosmology_t = {"_p_std__shared_ptrT_cosmobl__Cosmology_t", "std::shared_ptr< cosmobl::Cosmology > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_cosmobl__Object_t = {"_p_std__shared_ptrT_cosmobl__Object_t", "shared_ptr< cosmobl::Object > *|std::shared_ptr< cosmobl::Object > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_cosmobl__Pairs_t = {"_p_std__shared_ptrT_cosmobl__Pairs_t", "std::shared_ptr< cosmobl::Pairs > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_cosmobl__Triplets_t = {"_p_std__shared_ptrT_cosmobl__Triplets_t", "std::shared_ptr< cosmobl::Triplets > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t = {"_p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t", "std::shared_ptr< cosmobl::TwoPointCorrelation > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_void_t = {"_p_std__shared_ptrT_void_t", "std::shared_ptr< void > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t = {"_p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t", "vector< cosmobl::Cluster > *|std::vector< cosmobl::Cluster > *|vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *|std::vector< cosmobl::Cluster,std::allocator< cosmobl::Cluster > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_cosmobl__Cosmology_std__allocatorT_cosmobl__Cosmology_t_t = {"_p_std__vectorT_cosmobl__Cosmology_std__allocatorT_cosmobl__Cosmology_t_t", "std::vector< cosmobl::Cosmology > *|std::vector< cosmobl::Cosmology,std::allocator< cosmobl::Cosmology > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t = {"_p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t", "std::vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *|vector< cosmobl::Galaxy > *|std::vector< cosmobl::Galaxy > *|vector< cosmobl::Galaxy,std::allocator< cosmobl::Galaxy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t = {"_p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t", "vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *|vector< cosmobl::GenericObject > *|std::vector< cosmobl::GenericObject > *|std::vector< cosmobl::GenericObject,std::allocator< cosmobl::GenericObject > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t = {"_p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t", "vector< cosmobl::Halo > *|std::vector< cosmobl::Halo > *|vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *|std::vector< cosmobl::Halo,std::allocator< cosmobl::Halo > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t = {"_p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t", "vector< cosmobl::Mock > *|std::vector< cosmobl::Mock > *|vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *|std::vector< cosmobl::Mock,std::allocator< cosmobl::Mock > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t = {"_p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t", "std::vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *|vector< cosmobl::RandomObject,std::allocator< cosmobl::RandomObject > > *|vector< cosmobl::RandomObject > *|std::vector< cosmobl::RandomObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t = {"_p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t", "std::vector< enum cosmobl::Var > *|std::vector< cosmobl::Var > *|std::vector< enum cosmobl::Var,std::allocator< enum cosmobl::Var > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t__iterator = {"_p_std__vectorT_double_std__allocatorT_double_t_t__iterator", "std::vector< double,std::allocator< double > >::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_long_std__allocatorT_long_t_t = {"_p_std__vectorT_long_std__allocatorT_long_t_t", "std::vector< long,std::allocator< long > > *|std::vector< long > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t = {"_p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t", "std::vector< std::shared_ptr< cosmobl::Object > > *|std::vector< shared_ptr< cosmobl::Object > > *|std::vector< shared_ptr< cosmobl::Object >,std::allocator< shared_ptr< cosmobl::Object > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t = {"_p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t", "std::vector< std::shared_ptr< cosmobl::Pairs > > *|std::vector< std::shared_ptr< cosmobl::Pairs >,std::allocator< std::shared_ptr< cosmobl::Pairs > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string > *|std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t = {"_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t", "std::vector< std::vector< double > > *|std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *|std::vector< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_Doub,
  &_swigt__p_MatDoub,
  &_swigt__p_VecDoub,
  &_swigt__p_allocator_type,
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_cosmobl__Catalogue,
  &_swigt__p_cosmobl__ChainMesh,
  &_swigt__p_cosmobl__ChainMesh1D,
  &_swigt__p_cosmobl__ChainMesh2D,
  &_swigt__p_cosmobl__ChainMesh3D,
  &_swigt__p_cosmobl__ChainMesh_Catalogue,
  &_swigt__p_cosmobl__Cluster,
  &_swigt__p_cosmobl__Cosmology,
  &_swigt__p_cosmobl__Galaxy,
  &_swigt__p_cosmobl__GenericObject,
  &_swigt__p_cosmobl__Halo,
  &_swigt__p_cosmobl__LogNormal,
  &_swigt__p_cosmobl__Mock,
  &_swigt__p_cosmobl__ModelTwoPointCorrelation,
  &_swigt__p_cosmobl__Object,
  &_swigt__p_cosmobl__Pairs,
  &_swigt__p_cosmobl__Pairs2D,
  &_swigt__p_cosmobl__Pairs3D,
  &_swigt__p_cosmobl__RandomObject,
  &_swigt__p_cosmobl__ThreePointCorrelation,
  &_swigt__p_cosmobl__Triplets,
  &_swigt__p_cosmobl__Triplets2D,
  &_swigt__p_cosmobl__Triplets3D,
  &_swigt__p_cosmobl__TwoPointCorrelation,
  &_swigt__p_cosmobl__glob__CL,
  &_swigt__p_cosmobl__glob__GSL_f_pars,
  &_swigt__p_cosmobl__glob__STR_NG,
  &_swigt__p_cosmobl__glob__STR_SSM,
  &_swigt__p_cosmobl__glob__STR_SSM_EH,
  &_swigt__p_cosmobl__glob__STR_grid,
  &_swigt__p_cosmobl__glob__STR_grid_2D,
  &_swigt__p_cosmobl__glob__STR_xi,
  &_swigt__p_cosmobl__glob__STR_xi0K,
  &_swigt__p_cosmobl__glob__STR_xi0_model,
  &_swigt__p_cosmobl__glob__STR_xi2D_model,
  &_swigt__p_cosmobl__glob__STR_xi_EH,
  &_swigt__p_difference_type,
  &_swigt__p_double,
  &_swigt__p_f_double_p_void__double,
  &_swigt__p_f_p_double_size_t_p_void__double,
  &_swigt__p_f_q_const__double__double,
  &_swigt__p_f_q_const__double_q_const__double__double,
  &_swigt__p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double,
  &_swigt__p_int,
  &_swigt__p_long_long,
  &_swigt__p_p_PyObject,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_swigt__p_size_type,
  &_swigt__p_std__allocatorT_cosmobl__Cluster_t,
  &_swigt__p_std__allocatorT_cosmobl__Galaxy_t,
  &_swigt__p_std__allocatorT_cosmobl__GenericObject_t,
  &_swigt__p_std__allocatorT_cosmobl__Halo_t,
  &_swigt__p_std__allocatorT_cosmobl__Mock_t,
  &_swigt__p_std__allocatorT_cosmobl__RandomObject_t,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__shared_ptrT_cosmobl__Catalogue_t,
  &_swigt__p_std__shared_ptrT_cosmobl__Cosmology_t,
  &_swigt__p_std__shared_ptrT_cosmobl__Object_t,
  &_swigt__p_std__shared_ptrT_cosmobl__Pairs_t,
  &_swigt__p_std__shared_ptrT_cosmobl__Triplets_t,
  &_swigt__p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t,
  &_swigt__p_std__shared_ptrT_void_t,
  &_swigt__p_std__string,
  &_swigt__p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t,
  &_swigt__p_std__vectorT_cosmobl__Cosmology_std__allocatorT_cosmobl__Cosmology_t_t,
  &_swigt__p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t,
  &_swigt__p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t,
  &_swigt__p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t,
  &_swigt__p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t,
  &_swigt__p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t,
  &_swigt__p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t,
  &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
  &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__iterator,
  &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
  &_swigt__p_std__vectorT_long_std__allocatorT_long_t_t,
  &_swigt__p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t,
  &_swigt__p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t,
  &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  &_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_value_type,
};

static swig_cast_info _swigc__p_Doub[] = {  {&_swigt__p_Doub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MatDoub[] = {  {&_swigt__p_MatDoub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VecDoub[] = {  {&_swigt__p_VecDoub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Catalogue[] = {  {&_swigt__p_cosmobl__Catalogue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__ChainMesh[] = {  {&_swigt__p_cosmobl__ChainMesh1D, _p_cosmobl__ChainMesh1DTo_p_cosmobl__ChainMesh, 0, 0},  {&_swigt__p_cosmobl__ChainMesh3D, _p_cosmobl__ChainMesh3DTo_p_cosmobl__ChainMesh, 0, 0},  {&_swigt__p_cosmobl__ChainMesh_Catalogue, _p_cosmobl__ChainMesh_CatalogueTo_p_cosmobl__ChainMesh, 0, 0},  {&_swigt__p_cosmobl__ChainMesh, 0, 0, 0},  {&_swigt__p_cosmobl__ChainMesh2D, _p_cosmobl__ChainMesh2DTo_p_cosmobl__ChainMesh, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__ChainMesh1D[] = {  {&_swigt__p_cosmobl__ChainMesh1D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__ChainMesh2D[] = {  {&_swigt__p_cosmobl__ChainMesh2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__ChainMesh3D[] = {  {&_swigt__p_cosmobl__ChainMesh3D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__ChainMesh_Catalogue[] = {  {&_swigt__p_cosmobl__ChainMesh_Catalogue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Cluster[] = {  {&_swigt__p_cosmobl__Cluster, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Cosmology[] = {  {&_swigt__p_cosmobl__Cosmology, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Galaxy[] = {  {&_swigt__p_cosmobl__Galaxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__GenericObject[] = {  {&_swigt__p_cosmobl__GenericObject, 0, 0, 0},  {&_swigt__p_cosmobl__Galaxy, _p_cosmobl__GalaxyTo_p_cosmobl__GenericObject, 0, 0},  {&_swigt__p_cosmobl__RandomObject, _p_cosmobl__RandomObjectTo_p_cosmobl__GenericObject, 0, 0},  {&_swigt__p_cosmobl__Halo, _p_cosmobl__HaloTo_p_cosmobl__GenericObject, 0, 0},  {&_swigt__p_cosmobl__Mock, _p_cosmobl__MockTo_p_cosmobl__GenericObject, 0, 0},  {&_swigt__p_cosmobl__Cluster, _p_cosmobl__ClusterTo_p_cosmobl__GenericObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Halo[] = {  {&_swigt__p_cosmobl__Halo, 0, 0, 0},  {&_swigt__p_cosmobl__Mock, _p_cosmobl__MockTo_p_cosmobl__Halo, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__LogNormal[] = {  {&_swigt__p_cosmobl__LogNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Mock[] = {  {&_swigt__p_cosmobl__Mock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__ModelTwoPointCorrelation[] = {  {&_swigt__p_cosmobl__ModelTwoPointCorrelation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Object[] = {  {&_swigt__p_cosmobl__Object, 0, 0, 0},  {&_swigt__p_cosmobl__Galaxy, _p_cosmobl__GalaxyTo_p_cosmobl__Object, 0, 0},  {&_swigt__p_cosmobl__GenericObject, _p_cosmobl__GenericObjectTo_p_cosmobl__Object, 0, 0},  {&_swigt__p_cosmobl__RandomObject, _p_cosmobl__RandomObjectTo_p_cosmobl__Object, 0, 0},  {&_swigt__p_cosmobl__Halo, _p_cosmobl__HaloTo_p_cosmobl__Object, 0, 0},  {&_swigt__p_cosmobl__Mock, _p_cosmobl__MockTo_p_cosmobl__Object, 0, 0},  {&_swigt__p_cosmobl__Cluster, _p_cosmobl__ClusterTo_p_cosmobl__Object, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Pairs[] = {  {&_swigt__p_cosmobl__Pairs3D, _p_cosmobl__Pairs3DTo_p_cosmobl__Pairs, 0, 0},  {&_swigt__p_cosmobl__Pairs, 0, 0, 0},  {&_swigt__p_cosmobl__Pairs2D, _p_cosmobl__Pairs2DTo_p_cosmobl__Pairs, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Pairs2D[] = {  {&_swigt__p_cosmobl__Pairs2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Pairs3D[] = {  {&_swigt__p_cosmobl__Pairs3D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__RandomObject[] = {  {&_swigt__p_cosmobl__RandomObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__ThreePointCorrelation[] = {  {&_swigt__p_cosmobl__ThreePointCorrelation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Triplets[] = {  {&_swigt__p_cosmobl__Triplets2D, _p_cosmobl__Triplets2DTo_p_cosmobl__Triplets, 0, 0},  {&_swigt__p_cosmobl__Triplets3D, _p_cosmobl__Triplets3DTo_p_cosmobl__Triplets, 0, 0},  {&_swigt__p_cosmobl__Triplets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Triplets2D[] = {  {&_swigt__p_cosmobl__Triplets2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__Triplets3D[] = {  {&_swigt__p_cosmobl__Triplets3D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__TwoPointCorrelation[] = {  {&_swigt__p_cosmobl__TwoPointCorrelation, 0, 0, 0},  {&_swigt__p_cosmobl__ThreePointCorrelation, _p_cosmobl__ThreePointCorrelationTo_p_cosmobl__TwoPointCorrelation, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__CL[] = {  {&_swigt__p_cosmobl__glob__CL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__GSL_f_pars[] = {  {&_swigt__p_cosmobl__glob__GSL_f_pars, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_NG[] = {  {&_swigt__p_cosmobl__glob__STR_NG, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_SSM[] = {  {&_swigt__p_cosmobl__glob__STR_SSM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_SSM_EH[] = {  {&_swigt__p_cosmobl__glob__STR_SSM_EH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_grid[] = {  {&_swigt__p_cosmobl__glob__STR_grid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_grid_2D[] = {  {&_swigt__p_cosmobl__glob__STR_grid_2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_xi[] = {  {&_swigt__p_cosmobl__glob__STR_xi, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_xi0K[] = {  {&_swigt__p_cosmobl__glob__STR_xi0K, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_xi0_model[] = {  {&_swigt__p_cosmobl__glob__STR_xi0_model, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_xi2D_model[] = {  {&_swigt__p_cosmobl__glob__STR_xi2D_model, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cosmobl__glob__STR_xi_EH[] = {  {&_swigt__p_cosmobl__glob__STR_xi_EH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_double_p_void__double[] = {  {&_swigt__p_f_double_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_double_size_t_p_void__double[] = {  {&_swigt__p_f_p_double_size_t_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__double__double[] = {  {&_swigt__p_f_q_const__double__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__double_q_const__double__double[] = {  {&_swigt__p_f_q_const__double_q_const__double__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double[] = {  {&_swigt__p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_cosmobl__Cluster_t[] = {  {&_swigt__p_std__allocatorT_cosmobl__Cluster_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_cosmobl__Galaxy_t[] = {  {&_swigt__p_std__allocatorT_cosmobl__Galaxy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_cosmobl__GenericObject_t[] = {  {&_swigt__p_std__allocatorT_cosmobl__GenericObject_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_cosmobl__Halo_t[] = {  {&_swigt__p_std__allocatorT_cosmobl__Halo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_cosmobl__Mock_t[] = {  {&_swigt__p_std__allocatorT_cosmobl__Mock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_cosmobl__RandomObject_t[] = {  {&_swigt__p_std__allocatorT_cosmobl__RandomObject_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_cosmobl__Catalogue_t[] = {  {&_swigt__p_std__shared_ptrT_cosmobl__Catalogue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_cosmobl__Cosmology_t[] = {  {&_swigt__p_std__shared_ptrT_cosmobl__Cosmology_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_cosmobl__Object_t[] = {  {&_swigt__p_std__shared_ptrT_cosmobl__Object_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_cosmobl__Pairs_t[] = {  {&_swigt__p_std__shared_ptrT_cosmobl__Pairs_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_cosmobl__Triplets_t[] = {  {&_swigt__p_std__shared_ptrT_cosmobl__Triplets_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t[] = {  {&_swigt__p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_void_t[] = {  {&_swigt__p_std__shared_ptrT_void_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t[] = {  {&_swigt__p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_cosmobl__Cosmology_std__allocatorT_cosmobl__Cosmology_t_t[] = {  {&_swigt__p_std__vectorT_cosmobl__Cosmology_std__allocatorT_cosmobl__Cosmology_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t[] = {  {&_swigt__p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t[] = {  {&_swigt__p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t[] = {  {&_swigt__p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t[] = {  {&_swigt__p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t[] = {  {&_swigt__p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t[] = {  {&_swigt__p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = {  {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__iterator[] = {  {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_long_std__allocatorT_long_t_t[] = {  {&_swigt__p_std__vectorT_long_std__allocatorT_long_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t[] = {  {&_swigt__p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t[] = {  {&_swigt__p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_Doub,
  _swigc__p_MatDoub,
  _swigc__p_VecDoub,
  _swigc__p_allocator_type,
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_cosmobl__Catalogue,
  _swigc__p_cosmobl__ChainMesh,
  _swigc__p_cosmobl__ChainMesh1D,
  _swigc__p_cosmobl__ChainMesh2D,
  _swigc__p_cosmobl__ChainMesh3D,
  _swigc__p_cosmobl__ChainMesh_Catalogue,
  _swigc__p_cosmobl__Cluster,
  _swigc__p_cosmobl__Cosmology,
  _swigc__p_cosmobl__Galaxy,
  _swigc__p_cosmobl__GenericObject,
  _swigc__p_cosmobl__Halo,
  _swigc__p_cosmobl__LogNormal,
  _swigc__p_cosmobl__Mock,
  _swigc__p_cosmobl__ModelTwoPointCorrelation,
  _swigc__p_cosmobl__Object,
  _swigc__p_cosmobl__Pairs,
  _swigc__p_cosmobl__Pairs2D,
  _swigc__p_cosmobl__Pairs3D,
  _swigc__p_cosmobl__RandomObject,
  _swigc__p_cosmobl__ThreePointCorrelation,
  _swigc__p_cosmobl__Triplets,
  _swigc__p_cosmobl__Triplets2D,
  _swigc__p_cosmobl__Triplets3D,
  _swigc__p_cosmobl__TwoPointCorrelation,
  _swigc__p_cosmobl__glob__CL,
  _swigc__p_cosmobl__glob__GSL_f_pars,
  _swigc__p_cosmobl__glob__STR_NG,
  _swigc__p_cosmobl__glob__STR_SSM,
  _swigc__p_cosmobl__glob__STR_SSM_EH,
  _swigc__p_cosmobl__glob__STR_grid,
  _swigc__p_cosmobl__glob__STR_grid_2D,
  _swigc__p_cosmobl__glob__STR_xi,
  _swigc__p_cosmobl__glob__STR_xi0K,
  _swigc__p_cosmobl__glob__STR_xi0_model,
  _swigc__p_cosmobl__glob__STR_xi2D_model,
  _swigc__p_cosmobl__glob__STR_xi_EH,
  _swigc__p_difference_type,
  _swigc__p_double,
  _swigc__p_f_double_p_void__double,
  _swigc__p_f_p_double_size_t_p_void__double,
  _swigc__p_f_q_const__double__double,
  _swigc__p_f_q_const__double_q_const__double__double,
  _swigc__p_f_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double_q_const__double__double,
  _swigc__p_int,
  _swigc__p_long_long,
  _swigc__p_p_PyObject,
  _swigc__p_short,
  _swigc__p_signed_char,
  _swigc__p_size_type,
  _swigc__p_std__allocatorT_cosmobl__Cluster_t,
  _swigc__p_std__allocatorT_cosmobl__Galaxy_t,
  _swigc__p_std__allocatorT_cosmobl__GenericObject_t,
  _swigc__p_std__allocatorT_cosmobl__Halo_t,
  _swigc__p_std__allocatorT_cosmobl__Mock_t,
  _swigc__p_std__allocatorT_cosmobl__RandomObject_t,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__shared_ptrT_cosmobl__Catalogue_t,
  _swigc__p_std__shared_ptrT_cosmobl__Cosmology_t,
  _swigc__p_std__shared_ptrT_cosmobl__Object_t,
  _swigc__p_std__shared_ptrT_cosmobl__Pairs_t,
  _swigc__p_std__shared_ptrT_cosmobl__Triplets_t,
  _swigc__p_std__shared_ptrT_cosmobl__TwoPointCorrelation_t,
  _swigc__p_std__shared_ptrT_void_t,
  _swigc__p_std__string,
  _swigc__p_std__vectorT_cosmobl__Cluster_std__allocatorT_cosmobl__Cluster_t_t,
  _swigc__p_std__vectorT_cosmobl__Cosmology_std__allocatorT_cosmobl__Cosmology_t_t,
  _swigc__p_std__vectorT_cosmobl__Galaxy_std__allocatorT_cosmobl__Galaxy_t_t,
  _swigc__p_std__vectorT_cosmobl__GenericObject_std__allocatorT_cosmobl__GenericObject_t_t,
  _swigc__p_std__vectorT_cosmobl__Halo_std__allocatorT_cosmobl__Halo_t_t,
  _swigc__p_std__vectorT_cosmobl__Mock_std__allocatorT_cosmobl__Mock_t_t,
  _swigc__p_std__vectorT_cosmobl__RandomObject_std__allocatorT_cosmobl__RandomObject_t_t,
  _swigc__p_std__vectorT_cosmobl__Var_std__allocatorT_cosmobl__Var_t_t,
  _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
  _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__iterator,
  _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
  _swigc__p_std__vectorT_long_std__allocatorT_long_t_t,
  _swigc__p_std__vectorT_std__shared_ptrT_cosmobl__Object_t_std__allocatorT_std__shared_ptrT_cosmobl__Object_t_t_t,
  _swigc__p_std__vectorT_std__shared_ptrT_cosmobl__Pairs_t_std__allocatorT_std__shared_ptrT_cosmobl__Pairs_t_t_t,
  _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  _swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
  _swigc__p_value_type,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
  
  /* -----------------------------------------------------------------------------
   * global variable support code.
   * ----------------------------------------------------------------------------- */
  
  typedef struct swig_globalvar {
    char       *name;                  /* Name of global variable */
    PyObject *(*get_attr)(void);       /* Return the current value */
    int       (*set_attr)(PyObject *); /* Set the value */
    struct swig_globalvar *next;
  } swig_globalvar;
  
  typedef struct swig_varlinkobject {
    PyObject_HEAD
    swig_globalvar *vars;
  } swig_varlinkobject;
  
  SWIGINTERN PyObject *
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
    return PyUnicode_InternFromString("<Swig global variables>");
#else
    return PyString_FromString("<Swig global variables>");
#endif
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *str = PyUnicode_InternFromString("(");
    PyObject *tail;
    PyObject *joined;
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      tail = PyUnicode_FromString(var->name);
      joined = PyUnicode_Concat(str, tail);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
#else
    PyObject *str = PyString_FromString("(");
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
    }
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
    return str;
  }
  
  SWIGINTERN int
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
    char *tmp;
    PyObject *str = swig_varlink_str(v);
    fprintf(fp,"Swig global variables ");
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(str);
    return 0;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    PyObject *res = NULL;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->get_attr)();
        break;
      }
      var = var->next;
    }
    if (res == NULL && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN int
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
        /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        (char *)"swigvarlink",              /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        (printfunc) swig_varlink_print,     /* tp_print */
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        (reprfunc) swig_varlink_str,        /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        varlink__doc__,                     /* tp_doc */
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
        0,                                  /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
        0,                                  /* tp_version */
#endif
#ifdef COUNT_ALLOCS
        0,0,0,0                             /* tp_alloc -> tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
#if PY_VERSION_HEX < 0x02020000
      varlink_type.ob_type = &PyType_Type;
#else
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
#endif
    }
    return &varlink_type;
  }
  
  /* Create a variable linking object for use later */
  SWIGINTERN PyObject *
  SWIG_Python_newvarlink(void) {
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
    if (result) {
      result->vars = 0;
    }
    return ((PyObject*) result);
  }
  
  SWIGINTERN void 
  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
    swig_varlinkobject *v = (swig_varlinkobject *) p;
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
    if (gv) {
      size_t size = strlen(name)+1;
      gv->name = (char *)malloc(size);
      if (gv->name) {
        strncpy(gv->name,name,size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *_SWIG_globals = 0; 
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
    return _SWIG_globals;
  }
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              strncpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              strncpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md;
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
# if PY_VERSION_HEX >= 0x03020000
    PyModuleDef_HEAD_INIT,
# else
    {
      PyObject_HEAD_INIT(NULL)
      NULL, /* m_init */
      0,    /* m_index */
      NULL, /* m_copy */
    },
# endif
    (char *) SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    (PyCFunction) SwigPyObject_own,
    (PyCFunction) SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyObject *metatype_args;
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* metatype is used to implement static member variables. */
  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
  assert(metatype_args);
  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
  assert(metatype);
  Py_DECREF(metatype_args);
  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
  assert(PyType_Ready(metatype) >= 0);
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  PyDict_SetItemString(md,(char*)"cvar", SWIG_globals());
  SWIG_addvarlink(SWIG_globals(),(char*)"yotta",Swig_var_yotta_get, Swig_var_yotta_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"zetta",Swig_var_zetta_get, Swig_var_zetta_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"exa",Swig_var_exa_get, Swig_var_exa_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"peta",Swig_var_peta_get, Swig_var_peta_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"tera",Swig_var_tera_get, Swig_var_tera_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"giga",Swig_var_giga_get, Swig_var_giga_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"mega",Swig_var_mega_get, Swig_var_mega_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"kilo",Swig_var_kilo_get, Swig_var_kilo_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ecto",Swig_var_ecto_get, Swig_var_ecto_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"deca",Swig_var_deca_get, Swig_var_deca_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"deci",Swig_var_deci_get, Swig_var_deci_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"centi",Swig_var_centi_get, Swig_var_centi_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"milli",Swig_var_milli_get, Swig_var_milli_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"micro",Swig_var_micro_get, Swig_var_micro_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"nano",Swig_var_nano_get, Swig_var_nano_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"pico",Swig_var_pico_get, Swig_var_pico_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"femto",Swig_var_femto_get, Swig_var_femto_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"atto",Swig_var_atto_get, Swig_var_atto_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"zepto",Swig_var_zepto_get, Swig_var_zepto_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"yocto",Swig_var_yocto_get, Swig_var_yocto_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fINT",Swig_var_fINT_get, Swig_var_fINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fLONG",Swig_var_fLONG_get, Swig_var_fLONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fDP0",Swig_var_fDP0_get, Swig_var_fDP0_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fDP1",Swig_var_fDP1_get, Swig_var_fDP1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fDP2",Swig_var_fDP2_get, Swig_var_fDP2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fDP3",Swig_var_fDP3_get, Swig_var_fDP3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fDP4",Swig_var_fDP4_get, Swig_var_fDP4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fDP5",Swig_var_fDP5_get, Swig_var_fDP5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"fDP6",Swig_var_fDP6_get, Swig_var_fDP6_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ee3",Swig_var_ee3_get, Swig_var_ee3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"pi",Swig_var_pi_get, Swig_var_pi_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ee",Swig_var_ee_get, Swig_var_ee_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"hbar",Swig_var_hbar_get, Swig_var_hbar_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"cc",Swig_var_cc_get, Swig_var_cc_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"kB",Swig_var_kB_get, Swig_var_kB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"sSB",Swig_var_sSB_get, Swig_var_sSB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"el",Swig_var_el_get, Swig_var_el_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"alpha",Swig_var_alpha_get, Swig_var_alpha_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"epsilon0",Swig_var_epsilon0_get, Swig_var_epsilon0_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"mu0",Swig_var_mu0_get, Swig_var_mu0_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NAv",Swig_var_NAv_get, Swig_var_NAv_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GN",Swig_var_GN_get, Swig_var_GN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"gn",Swig_var_gn_get, Swig_var_gn_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"lP",Swig_var_lP_get, Swig_var_lP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MP",Swig_var_MP_get, Swig_var_MP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Msol",Swig_var_Msol_get, Swig_var_Msol_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"me",Swig_var_me_get, Swig_var_me_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"mn",Swig_var_mn_get, Swig_var_mn_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"mp",Swig_var_mp_get, Swig_var_mp_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"au",Swig_var_au_get, Swig_var_au_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"pc",Swig_var_pc_get, Swig_var_pc_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TCMB",Swig_var_TCMB_get, Swig_var_TCMB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"yr",Swig_var_yr_get, Swig_var_yr_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"col_default",Swig_var_col_default_get, Swig_var_col_default_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"col_red",Swig_var_col_red_get, Swig_var_col_red_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"col_green",Swig_var_col_green_get, Swig_var_col_green_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"col_blue",Swig_var_col_blue_get, Swig_var_col_blue_set);
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

